This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3376

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

Authored by indygreg on Apr 14 2018, 8:21 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGdfc51a482031: registrar: replace "cmdtype" with an intent-based mechanism (API)
Summary

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.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Apr 14 2018, 8:21 PM
durin42 accepted this revision.Apr 16 2018, 6:51 PM
This revision is now accepted and ready to land.Apr 16 2018, 6:51 PM
Closed by commit rHGdfc51a482031: registrar: replace "cmdtype" with an intent-based mechanism (API) (authored by indygreg). · Explain WhyApr 16 2018, 7:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 8319

mercurial/commands.py

) )
release = lockmod.release release = lockmod.release
table = {} table = {}
table.update(debugcommandsmod.command._table) table.update(debugcommandsmod.command._table)
command = registrar.command(table) command = registrar.command(table)
readonly = registrar.command.readonly INTENT_READONLY = registrar.INTENT_READONLY
# common command options # common command options
globalopts = [ globalopts = [
('R', 'repository', '', ('R', 'repository', '',
_('repository root directory or name of overlay bundle file'), _('repository root directory or name of overlay bundle file'),
_('REPO')), _('REPO')),
('', 'cwd', '', ('', 'cwd', '',
ui.status(_('(branches are permanent and global, ' ui.status(_('(branches are permanent and global, '
'did you want a bookmark?)\n')) 'did you want a bookmark?)\n'))
@command('branches', @command('branches',
[('a', 'active', False, [('a', 'active', False,
_('show only branches that have unmerged heads (DEPRECATED)')), _('show only branches that have unmerged heads (DEPRECATED)')),
('c', 'closed', False, _('show normal and closed branches')), ('c', 'closed', False, _('show normal and closed branches')),
] + formatteropts, ] + formatteropts,
_('[-c]'), cmdtype=readonly) _('[-c]'),
intents={INTENT_READONLY})
def branches(ui, repo, active=False, closed=False, **opts): def branches(ui, repo, active=False, closed=False, **opts):
"""list repository named branches """list repository named branches
List the repository's named branches, indicating which ones are List the repository's named branches, indicating which ones are
inactive. If -c/--closed is specified, also list branches which have inactive. If -c/--closed is specified, also list branches which have
been marked closed (see :hg:`commit --close-branch`). been marked closed (see :hg:`commit --close-branch`).
Use the command :hg:`update` to switch to an existing branch. Use the command :hg:`update` to switch to an existing branch.
@command('cat', @command('cat',
[('o', 'output', '', [('o', 'output', '',
_('print output to file with formatted name'), _('FORMAT')), _('print output to file with formatted name'), _('FORMAT')),
('r', 'rev', '', _('print the given revision'), _('REV')), ('r', 'rev', '', _('print the given revision'), _('REV')),
('', 'decode', None, _('apply any matching decode filter')), ('', 'decode', None, _('apply any matching decode filter')),
] + walkopts + formatteropts, ] + walkopts + formatteropts,
_('[OPTION]... FILE...'), _('[OPTION]... FILE...'),
inferrepo=True, cmdtype=readonly) inferrepo=True,
intents={INTENT_READONLY})
def cat(ui, repo, file1, *pats, **opts): def cat(ui, repo, file1, *pats, **opts):
"""output the current or given revision of files """output the current or given revision of files
Print the specified files as they were at the given revision. If Print the specified files as they were at the given revision. If
no revision is given, the parent of the working directory is used. no revision is given, the parent of the working directory is used.
Output may be to a file, in which case the name of the file is Output may be to a file, in which case the name of the file is
given using a template string. See :hg:`help templates`. In addition given using a template string. See :hg:`help templates`. In addition
cmdutil.commitstatus(repo, node, branch, bheads, opts) cmdutil.commitstatus(repo, node, branch, bheads, opts)
@command('config|showconfig|debugconfig', @command('config|showconfig|debugconfig',
[('u', 'untrusted', None, _('show untrusted configuration options')), [('u', 'untrusted', None, _('show untrusted configuration options')),
('e', 'edit', None, _('edit user config')), ('e', 'edit', None, _('edit user config')),
('l', 'local', None, _('edit repository config')), ('l', 'local', None, _('edit repository config')),
('g', 'global', None, _('edit global config'))] + formatteropts, ('g', 'global', None, _('edit global config'))] + formatteropts,
_('[-u] [NAME]...'), _('[-u] [NAME]...'),
optionalrepo=True, cmdtype=readonly) optionalrepo=True,
intents={INTENT_READONLY})
def config(ui, repo, *values, **opts): def config(ui, repo, *values, **opts):
"""show combined config settings from all hgrc files """show combined config settings from all hgrc files
With no arguments, print names and values of all config items. With no arguments, print names and values of all config items.
With one argument of the form section.name, print just the value With one argument of the form section.name, print just the value
of that config item. of that config item.
cmdlist = [' '.join(c[0]) for c in cmdlist.values()] cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
ui.write("%s\n" % "\n".join(sorted(cmdlist))) ui.write("%s\n" % "\n".join(sorted(cmdlist)))
@command('^diff', @command('^diff',
[('r', 'rev', [], _('revision'), _('REV')), [('r', 'rev', [], _('revision'), _('REV')),
('c', 'change', '', _('change made by revision'), _('REV')) ('c', 'change', '', _('change made by revision'), _('REV'))
] + diffopts + diffopts2 + walkopts + subrepoopts, ] + diffopts + diffopts2 + walkopts + subrepoopts,
_('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'), _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'),
inferrepo=True, cmdtype=readonly) inferrepo=True,
intents={INTENT_READONLY})
def diff(ui, repo, *pats, **opts): def diff(ui, repo, *pats, **opts):
"""diff repository (or selected files) """diff repository (or selected files)
Show differences between revisions for the specified files. Show differences between revisions for the specified files.
Differences between files are shown using the unified diff format. Differences between files are shown using the unified diff format.
.. note:: .. note::
root=opts.get('root')) root=opts.get('root'))
@command('^export', @command('^export',
[('o', 'output', '', [('o', 'output', '',
_('print output to file with formatted name'), _('FORMAT')), _('print output to file with formatted name'), _('FORMAT')),
('', 'switch-parent', None, _('diff against the second parent')), ('', 'switch-parent', None, _('diff against the second parent')),
('r', 'rev', [], _('revisions to export'), _('REV')), ('r', 'rev', [], _('revisions to export'), _('REV')),
] + diffopts + formatteropts, ] + diffopts + formatteropts,
_('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'), cmdtype=readonly) _('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'),
intents={INTENT_READONLY})
def export(ui, repo, *changesets, **opts): def export(ui, repo, *changesets, **opts):
"""dump the header and diffs for one or more changesets """dump the header and diffs for one or more changesets
Print the changeset header and diffs for one or more revisions. Print the changeset header and diffs for one or more revisions.
If no revision is given, the parent of the working directory is used. If no revision is given, the parent of the working directory is used.
The information shown in the changeset header is: author, date, The information shown in the changeset header is: author, date,
branch name (if non-default), changeset hash, parent(s) and commit branch name (if non-default), changeset hash, parent(s) and commit
cmdutil.export(repo, revs, fm, fntemplate=fntemplate, cmdutil.export(repo, revs, fm, fntemplate=fntemplate,
switch_parent=opts.get('switch_parent'), switch_parent=opts.get('switch_parent'),
opts=patch.diffallopts(ui, opts)) opts=patch.diffallopts(ui, opts))
@command('files', @command('files',
[('r', 'rev', '', _('search the repository as it is in REV'), _('REV')), [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
('0', 'print0', None, _('end filenames with NUL, for use with xargs')), ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
] + walkopts + formatteropts + subrepoopts, ] + walkopts + formatteropts + subrepoopts,
_('[OPTION]... [FILE]...'), cmdtype=readonly) _('[OPTION]... [FILE]...'),
intents={INTENT_READONLY})
def files(ui, repo, *pats, **opts): def files(ui, repo, *pats, **opts):
"""list tracked files """list tracked files
Print files under Mercurial control in the working directory or Print files under Mercurial control in the working directory or
specified revision for given files (excluding removed files). specified revision for given files (excluding removed files).
Files can be specified as filenames or filesets. Files can be specified as filenames or filesets.
If no files are given to match, this command prints the names If no files are given to match, this command prints the names
_('print only filenames and revisions that match')), _('print only filenames and revisions that match')),
('n', 'line-number', None, _('print matching line numbers')), ('n', 'line-number', None, _('print matching line numbers')),
('r', 'rev', [], ('r', 'rev', [],
_('only search files changed within revision range'), _('REV')), _('only search files changed within revision range'), _('REV')),
('u', 'user', None, _('list the author (long with -v)')), ('u', 'user', None, _('list the author (long with -v)')),
('d', 'date', None, _('list the date (short with -q)')), ('d', 'date', None, _('list the date (short with -q)')),
] + formatteropts + walkopts, ] + formatteropts + walkopts,
_('[OPTION]... PATTERN [FILE]...'), _('[OPTION]... PATTERN [FILE]...'),
inferrepo=True, cmdtype=readonly) inferrepo=True,
intents={INTENT_READONLY})
def grep(ui, repo, pattern, *pats, **opts): def grep(ui, repo, pattern, *pats, **opts):
"""search revision history for a pattern in specified files """search revision history for a pattern in specified files
Search revision history for a regular expression in the specified Search revision history for a regular expression in the specified
files or the entire project. files or the entire project.
By default, grep prints the most recent revision number for each By default, grep prints the most recent revision number for each
file in which it finds a match. To get it to print every revision file in which it finds a match. To get it to print every revision
@command('heads', @command('heads',
[('r', 'rev', '', [('r', 'rev', '',
_('show only heads which are descendants of STARTREV'), _('STARTREV')), _('show only heads which are descendants of STARTREV'), _('STARTREV')),
('t', 'topo', False, _('show topological heads only')), ('t', 'topo', False, _('show topological heads only')),
('a', 'active', False, _('show active branchheads only (DEPRECATED)')), ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
('c', 'closed', False, _('show normal and closed branch heads')), ('c', 'closed', False, _('show normal and closed branch heads')),
] + templateopts, ] + templateopts,
_('[-ct] [-r STARTREV] [REV]...'), cmdtype=readonly) _('[-ct] [-r STARTREV] [REV]...'),
intents={INTENT_READONLY})
def heads(ui, repo, *branchrevs, **opts): def heads(ui, repo, *branchrevs, **opts):
"""show branch heads """show branch heads
With no arguments, show all open branch heads in the repository. With no arguments, show all open branch heads in the repository.
Branch heads are changesets that have no descendants on the Branch heads are changesets that have no descendants on the
same branch. They are where development generally takes place and same branch. They are where development generally takes place and
are the usual targets for update and merge operations. are the usual targets for update and merge operations.
@command('help', @command('help',
[('e', 'extension', None, _('show only help for extensions')), [('e', 'extension', None, _('show only help for extensions')),
('c', 'command', None, _('show only help for commands')), ('c', 'command', None, _('show only help for commands')),
('k', 'keyword', None, _('show topics matching keyword')), ('k', 'keyword', None, _('show topics matching keyword')),
('s', 'system', [], _('show help for specific platform(s)')), ('s', 'system', [], _('show help for specific platform(s)')),
], ],
_('[-ecks] [TOPIC]'), _('[-ecks] [TOPIC]'),
norepo=True, cmdtype=readonly) norepo=True,
intents={INTENT_READONLY})
def help_(ui, name=None, **opts): def help_(ui, name=None, **opts):
"""show help for a given topic or a help overview """show help for a given topic or a help overview
With no arguments, print a list of commands with short help messages. With no arguments, print a list of commands with short help messages.
Given a topic, extension, or command name, print help for that Given a topic, extension, or command name, print help for that
topic. topic.
_('identify the specified revision'), _('REV')), _('identify the specified revision'), _('REV')),
('n', 'num', None, _('show local revision number')), ('n', 'num', None, _('show local revision number')),
('i', 'id', None, _('show global revision id')), ('i', 'id', None, _('show global revision id')),
('b', 'branch', None, _('show branch')), ('b', 'branch', None, _('show branch')),
('t', 'tags', None, _('show tags')), ('t', 'tags', None, _('show tags')),
('B', 'bookmarks', None, _('show bookmarks')), ('B', 'bookmarks', None, _('show bookmarks')),
] + remoteopts + formatteropts, ] + remoteopts + formatteropts,
_('[-nibtB] [-r REV] [SOURCE]'), _('[-nibtB] [-r REV] [SOURCE]'),
optionalrepo=True, cmdtype=readonly) optionalrepo=True,
intents={INTENT_READONLY})
def identify(ui, repo, source=None, rev=None, def identify(ui, repo, source=None, rev=None,
num=None, id=None, branch=None, tags=None, bookmarks=None, **opts): num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
"""identify the working directory or specified revision """identify the working directory or specified revision
Print a summary identifying the repository state at REV using one or Print a summary identifying the repository state at REV using one or
two parent hash identifiers, followed by a "+" if the working two parent hash identifiers, followed by a "+" if the working
directory has uncommitted changes, the branch name (if not default), directory has uncommitted changes, the branch name (if not default),
a list of tags, and a list of bookmarks. a list of tags, and a list of bookmarks.
_('show only changesets within the given named branch (DEPRECATED)'), _('show only changesets within the given named branch (DEPRECATED)'),
_('BRANCH')), _('BRANCH')),
('b', 'branch', [], ('b', 'branch', [],
_('show changesets within the given named branch'), _('BRANCH')), _('show changesets within the given named branch'), _('BRANCH')),
('P', 'prune', [], ('P', 'prune', [],
_('do not display revision or any of its ancestors'), _('REV')), _('do not display revision or any of its ancestors'), _('REV')),
] + logopts + walkopts, ] + logopts + walkopts,
_('[OPTION]... [FILE]'), _('[OPTION]... [FILE]'),
inferrepo=True, cmdtype=readonly) inferrepo=True,
intents={INTENT_READONLY})
def log(ui, repo, *pats, **opts): def log(ui, repo, *pats, **opts):
"""show revision history of entire repository or files """show revision history of entire repository or files
Print the revision history of the specified files or the entire Print the revision history of the specified files or the entire
project. project.
If no revision range is specified, the default is ``tip:0`` unless If no revision range is specified, the default is ``tip:0`` unless
--follow is set, in which case the working directory parent is --follow is set, in which case the working directory parent is
else: else:
displayfn = logcmdutil.displayrevs displayfn = logcmdutil.displayrevs
displayfn(ui, repo, revs, displayer, getrenamed) displayfn(ui, repo, revs, displayer, getrenamed)
@command('manifest', @command('manifest',
[('r', 'rev', '', _('revision to display'), _('REV')), [('r', 'rev', '', _('revision to display'), _('REV')),
('', 'all', False, _("list files from all revisions"))] ('', 'all', False, _("list files from all revisions"))]
+ formatteropts, + formatteropts,
_('[-r REV]'), cmdtype=readonly) _('[-r REV]'),
intents={INTENT_READONLY})
def manifest(ui, repo, node=None, rev=None, **opts): def manifest(ui, repo, node=None, rev=None, **opts):
"""output the current or given revision of the project manifest """output the current or given revision of the project manifest
Print a list of version controlled files for the given revision. Print a list of version controlled files for the given revision.
If no revision is given, the first parent of the working directory If no revision is given, the first parent of the working directory
is used, or the null revision if no revision is checked out. is used, or the null revision if no revision is checked out.
With -v, print file permissions, symlink and executable bits. With -v, print file permissions, symlink and executable bits.
displayer = logcmdutil.changesetdisplayer(ui, repo, opts) displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
for n in p: for n in p:
if n != nullid: if n != nullid:
displayer.show(repo[n]) displayer.show(repo[n])
displayer.close() displayer.close()
@command('paths', formatteropts, _('[NAME]'), optionalrepo=True, @command('paths', formatteropts, _('[NAME]'), optionalrepo=True,
cmdtype=readonly) intents={INTENT_READONLY})
def paths(ui, repo, search=None, **opts): def paths(ui, repo, search=None, **opts):
"""show aliases for remote repositories """show aliases for remote repositories
Show definition of symbolic path name NAME. If no name is given, Show definition of symbolic path name NAME. If no name is given,
show definition of all available names. show definition of all available names.
Option -q/--quiet suppresses all output when searching for NAME Option -q/--quiet suppresses all output when searching for NAME
and shows only the path names when listing all definitions. and shows only the path names when listing all definitions.
Returns 0 on success, 1 if no rollback data is available. Returns 0 on success, 1 if no rollback data is available.
""" """
if not ui.configbool('ui', 'rollback'): if not ui.configbool('ui', 'rollback'):
raise error.Abort(_('rollback is disabled because it is unsafe'), raise error.Abort(_('rollback is disabled because it is unsafe'),
hint=('see `hg help -v rollback` for information')) hint=('see `hg help -v rollback` for information'))
return repo.rollback(dryrun=opts.get(r'dry_run'), return repo.rollback(dryrun=opts.get(r'dry_run'),
force=opts.get(r'force')) force=opts.get(r'force'))
@command('root', [], cmdtype=readonly) @command('root', [], intents={INTENT_READONLY})
def root(ui, repo): def root(ui, repo):
"""print the root (top) of the current working directory """print the root (top) of the current working directory
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
""" """
ui.write(repo.root + "\n") ui.write(repo.root + "\n")
('n', 'no-status', None, _('hide status prefix')), ('n', 'no-status', None, _('hide status prefix')),
('t', 'terse', '', _('show the terse output (EXPERIMENTAL)')), ('t', 'terse', '', _('show the terse output (EXPERIMENTAL)')),
('C', 'copies', None, _('show source of copied files')), ('C', 'copies', None, _('show source of copied files')),
('0', 'print0', None, _('end filenames with NUL, for use with xargs')), ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
('', 'rev', [], _('show difference from revision'), _('REV')), ('', 'rev', [], _('show difference from revision'), _('REV')),
('', 'change', '', _('list the changed files of a revision'), _('REV')), ('', 'change', '', _('list the changed files of a revision'), _('REV')),
] + walkopts + subrepoopts + formatteropts, ] + walkopts + subrepoopts + formatteropts,
_('[OPTION]... [FILE]...'), _('[OPTION]... [FILE]...'),
inferrepo=True, cmdtype=readonly) inferrepo=True,
intents={INTENT_READONLY})
def status(ui, repo, *pats, **opts): def status(ui, repo, *pats, **opts):
"""show changed files in the working directory """show changed files in the working directory
Show status of files in the repository. If names are given, only Show status of files in the repository. If names are given, only
files that match are shown. Files that are clean or ignored or files that match are shown. Files that are clean or ignored or
the source of a copy/move operation, are not listed unless the source of a copy/move operation, are not listed unless
-c/--clean, -i/--ignored, -C/--copies or -A/--all are given. -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
Unless options described with "show only ..." are given, the Unless options described with "show only ..." are given, the
if ((ui.verbose or ui.configbool('commands', 'status.verbose')) if ((ui.verbose or ui.configbool('commands', 'status.verbose'))
and not ui.plain()): and not ui.plain()):
cmdutil.morestatus(repo, fm) cmdutil.morestatus(repo, fm)
fm.end() fm.end()
@command('^summary|sum', @command('^summary|sum',
[('', 'remote', None, _('check for push and pull'))], [('', 'remote', None, _('check for push and pull'))],
'[--remote]', cmdtype=readonly) '[--remote]',
intents={INTENT_READONLY})
def summary(ui, repo, **opts): def summary(ui, repo, **opts):
"""summarize working directory state """summarize working directory state
This generates a brief summary of the working directory state, This generates a brief summary of the working directory state,
including parents, branch, commit status, phase and available updates. including parents, branch, commit status, phase and available updates.
With the --remote option, this will check the default paths for With the --remote option, this will check the default paths for
incoming and outgoing changes. This can be time-consuming. incoming and outgoing changes. This can be time-consuming.
scmutil.revsingle(repo, rev_).rev() == nullrev): scmutil.revsingle(repo, rev_).rev() == nullrev):
raise error.Abort(_("cannot tag null revision")) raise error.Abort(_("cannot tag null revision"))
tagsmod.tag(repo, names, node, message, opts.get('local'), tagsmod.tag(repo, names, node, message, opts.get('local'),
opts.get('user'), date, editor=editor) opts.get('user'), date, editor=editor)
finally: finally:
release(lock, wlock) release(lock, wlock)
@command('tags', formatteropts, '', cmdtype=readonly) @command('tags', formatteropts, '', intents={INTENT_READONLY})
def tags(ui, repo, **opts): def tags(ui, repo, **opts):
"""list repository tags """list repository tags
This lists both regular and local tags. When the -v/--verbose This lists both regular and local tags. When the -v/--verbose
switch is used, a third column "local" is printed for local tags. switch is used, a third column "local" is printed for local tags.
When the -q/--quiet switch is used, only the tag name is printed. When the -q/--quiet switch is used, only the tag name is printed.
Returns 0 on success. Returns 0 on success.
Please see https://mercurial-scm.org/wiki/RepositoryCorruption Please see https://mercurial-scm.org/wiki/RepositoryCorruption
for more information about recovery from corruption of the for more information about recovery from corruption of the
repository. repository.
Returns 0 on success, 1 if errors are encountered. Returns 0 on success, 1 if errors are encountered.
""" """
return hg.verify(repo) return hg.verify(repo)
@command('version', [] + formatteropts, norepo=True, cmdtype=readonly) @command('version', [] + formatteropts, norepo=True,
intents={INTENT_READONLY})
def version_(ui, **opts): def version_(ui, **opts):
"""output version and copyright information""" """output version and copyright information"""
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if ui.verbose: if ui.verbose:
ui.pager('version') ui.pager('version')
fm = ui.formatter("version", opts) fm = ui.formatter("version", opts)
fm.startitem() fm.startitem()
fm.write("ver", _("Mercurial Distributed SCM (version %s)\n"), fm.write("ver", _("Mercurial Distributed SCM (version %s)\n"),

mercurial/dispatch.py

error, error,
extensions, extensions,
fancyopts, fancyopts,
help, help,
hg, hg,
hook, hook,
profiling, profiling,
pycompat, pycompat,
registrar,
scmutil, scmutil,
ui as uimod, ui as uimod,
util, util,
) )
from .utils import ( from .utils import (
procutil, procutil,
stringutil, stringutil,
) )
unrecoverablewrite = registrar.command.unrecoverablewrite
class request(object): class request(object):
def __init__(self, args, ui=None, repo=None, fin=None, fout=None, def __init__(self, args, ui=None, repo=None, fin=None, fout=None,
ferr=None, prereposetups=None): ferr=None, prereposetups=None):
self.args = args self.args = args
self.ui = ui self.ui = ui
self.repo = repo self.repo = repo
# input/output/error streams # input/output/error streams
self.__doc__ = doc self.__doc__ = doc
@property @property
def args(self): def args(self):
args = pycompat.maplist(util.expandpath, self.givenargs) args = pycompat.maplist(util.expandpath, self.givenargs)
return aliasargs(self.fn, args) return aliasargs(self.fn, args)
def __getattr__(self, name): def __getattr__(self, name):
adefaults = {r'norepo': True, r'cmdtype': unrecoverablewrite, adefaults = {r'norepo': True, r'intents': set(),
r'optionalrepo': False, r'inferrepo': False} r'optionalrepo': False, r'inferrepo': False}
if name not in adefaults: if name not in adefaults:
raise AttributeError(name) raise AttributeError(name)
if self.badalias or util.safehasattr(self, 'shell'): if self.badalias or util.safehasattr(self, 'shell'):
return adefaults[name] return adefaults[name]
return getattr(self.fn, name) return getattr(self.fn, name)
def __call__(self, ui, *args, **opts): def __call__(self, ui, *args, **opts):

mercurial/registrar.py

a local repository. If no repository can be found, None will be passed a local repository. If no repository can be found, None will be passed
to the decorated function. to the decorated function.
The `inferrepo` argument defines whether to try to find a repository from The `inferrepo` argument defines whether to try to find a repository from
the command line arguments. If True, arguments will be examined for the command line arguments. If True, arguments will be examined for
potential repository locations. See ``findrepo()``. If a repository is potential repository locations. See ``findrepo()``. If a repository is
found, it will be used and passed to the decorated function. found, it will be used and passed to the decorated function.
There are three constants in the class which tells what type of the command The `intents` argument defines a set of intended actions or capabilities
that is. That information will be helpful at various places. It will be also the command is taking. These intents can be used to affect the construction
be used to decide what level of access the command has on hidden commits. of the repository object passed to the command. For example, commands
The constants are: declaring that they are read-only could receive a repository that doesn't
have any methods allowing repository mutation. Other intents could be used
`unrecoverablewrite` is for those write commands which can't be recovered to prevent the command from running if the requested intent could not be
like push. fulfilled.
`recoverablewrite` is for write commands which can be recovered like commit.
`readonly` is for commands which are read only. The following intents are defined:
readonly
The command is read-only
The signature of the decorated function looks like this: The signature of the decorated function looks like this:
def cmd(ui[, repo] [, <args>] [, <options>]) def cmd(ui[, repo] [, <args>] [, <options>])
`repo` is required if `norepo` is False. `repo` is required if `norepo` is False.
`<args>` are positional args (or `*args`) arguments, of non-option `<args>` are positional args (or `*args`) arguments, of non-option
arguments from the command line. arguments from the command line.
`<options>` are keyword arguments (or `**options`) of option arguments `<options>` are keyword arguments (or `**options`) of option arguments
from the command line. from the command line.
See the WritingExtensions and MercurialApi documentation for more exhaustive See the WritingExtensions and MercurialApi documentation for more exhaustive
descriptions and examples. descriptions and examples.
""" """
unrecoverablewrite = "unrecoverable"
recoverablewrite = "recoverable"
readonly = "readonly"
possiblecmdtypes = {unrecoverablewrite, recoverablewrite, readonly}
def _doregister(self, func, name, options=(), synopsis=None, def _doregister(self, func, name, options=(), synopsis=None,
norepo=False, optionalrepo=False, inferrepo=False, norepo=False, optionalrepo=False, inferrepo=False,
cmdtype=unrecoverablewrite): intents=None):
if cmdtype not in self.possiblecmdtypes:
raise error.ProgrammingError("unknown cmdtype value '%s' for "
"'%s' command" % (cmdtype, name))
func.norepo = norepo func.norepo = norepo
func.optionalrepo = optionalrepo func.optionalrepo = optionalrepo
func.inferrepo = inferrepo func.inferrepo = inferrepo
func.cmdtype = cmdtype func.intents = intents or set()
if synopsis: if synopsis:
self._table[name] = func, list(options), synopsis self._table[name] = func, list(options), synopsis
else: else:
self._table[name] = func, list(options) self._table[name] = func, list(options)
return func return func
INTENT_READONLY = b'readonly'
class revsetpredicate(_funcregistrarbase): class revsetpredicate(_funcregistrarbase):
"""Decorator to register revset predicate """Decorator to register revset predicate
Usage:: Usage::
revsetpredicate = registrar.revsetpredicate() revsetpredicate = registrar.revsetpredicate()
@revsetpredicate('mypredicate(arg1, arg2[, arg3])') @revsetpredicate('mypredicate(arg1, arg2[, arg3])')

tests/test-directaccess.t

2147483647:ffffffffffff 2147483647:ffffffffffff
$ hg log -qr 'null:wdir() & rev(-1)' $ hg log -qr 'null:wdir() & rev(-1)'
-1:000000000000 -1:000000000000
$ hg log -qr 'null:wdir() & rev(2147483647)' $ hg log -qr 'null:wdir() & rev(2147483647)'
2147483647:ffffffffffff 2147483647:ffffffffffff
$ hg log -qr 'null:wdir() & 2147483647' $ hg log -qr 'null:wdir() & 2147483647'
2147483647:ffffffffffff 2147483647:ffffffffffff
Commands with undefined cmdtype should not work right now Commands with undefined intent should not work right now
$ hg phase -r 28ad74 $ hg phase -r 28ad74
abort: hidden revision '28ad74' was rewritten as: 2443a0e66469! abort: hidden revision '28ad74' was rewritten as: 2443a0e66469!
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [255]
$ hg phase -r 2 $ hg phase -r 2
abort: hidden revision '2' was rewritten as: 2443a0e66469! abort: hidden revision '2' was rewritten as: 2443a0e66469!