( )⚙ D11560 errors: raise InputError on bad revset to revrange() iff provided by the user

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11560

errors: raise InputError on bad revset to revrange() iff provided by the user
ClosedPublic

Authored by martinvonz on Oct 1 2021, 3:51 PM.

Details

Reviewers
durin42
Alphare
Group Reviewers
hg-reviewers
Commits
rHG5ced12cfa41b: errors: raise InputError on bad revset to revrange() iff provided by the user
Summary

Most callers of scmutil.revrange() pass in a revset provided by the
user. If there are problems resolving that, it should result in an
InputError and exit code 10 (when using detailed exit
codes). However, there are also some callers that pass in revsets not
provided by the user. InputError is not appropriate in those
cases. This patch therefore introduces a wrapper around
scmutil.revrange() that simply converts the exception type. I put it
in logcmdutil.py since that seems to be the lowest-level module in
the (poorly defined) UI layer.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 30517

contrib/synthrepo.py

nullrev, nullrev,
short, short,
) )
from mercurial import ( from mercurial import (
context, context,
diffutil, diffutil,
error, error,
hg, hg,
logcmdutil,
patch, patch,
pycompat, pycompat,
registrar, registrar,
scmutil,
) )
from mercurial.utils import dateutil from mercurial.utils import dateutil
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
# be specifying the version(s) of Mercurial they are tested with, or # be specifying the version(s) of Mercurial they are tested with, or
# leave the attribute unspecified. # leave the attribute unspecified.
testedwith = 'ships-with-hg-core' testedwith = 'ships-with-hg-core'
linelengths = zerodict() linelengths = zerodict()
interarrival = zerodict() interarrival = zerodict()
parents = zerodict() parents = zerodict()
dirsadded = zerodict() dirsadded = zerodict()
tzoffset = zerodict() tzoffset = zerodict()
# If a mercurial repo is available, also model the commit history. # If a mercurial repo is available, also model the commit history.
if repo: if repo:
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
revs.sort() revs.sort()
progress = ui.makeprogress( progress = ui.makeprogress(
_('analyzing'), unit=_('changesets'), total=len(revs) _('analyzing'), unit=_('changesets'), total=len(revs)
) )
for i, rev in enumerate(revs): for i, rev in enumerate(revs):
progress.update(i) progress.update(i)
ctx = repo[rev] ctx = repo[rev]

hgext/closehead.py

from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
cmdutil, cmdutil,
context, context,
error, error,
pycompat, pycompat,
registrar, registrar,
scmutil, logcmdutil,
) )
cmdtable = {} cmdtable = {}
command = registrar.command(cmdtable) command = registrar.command(cmdtable)
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
# be specifying the version(s) of Mercurial they are tested with, or # be specifying the version(s) of Mercurial they are tested with, or
# leave the attribute unspecified. # leave the attribute unspecified.
ret = repo.commitctx(cctx, True) ret = repo.commitctx(cctx, True)
bookmarks.update(repo, [rev, None], ret) bookmarks.update(repo, [rev, None], ret)
cctx.markcommitted(ret) cctx.markcommitted(ret)
tr.close() tr.close()
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs += tuple(opts.get(b'rev', [])) revs += tuple(opts.get(b'rev', []))
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
if not revs: if not revs:
raise error.Abort(_(b'no revisions specified')) raise error.Abort(_(b'no revisions specified'))
heads = [] heads = []
for branch in repo.branchmap(): for branch in repo.branchmap():
heads.extend(repo.branchheads(branch)) heads.extend(repo.branchheads(branch))
heads = {repo[h].rev() for h in heads} heads = {repo[h].rev() for h in heads}

hgext/convert/hg.py

) )
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
context, context,
error, error,
exchange, exchange,
hg, hg,
lock as lockmod, lock as lockmod,
logcmdutil,
merge as mergemod, merge as mergemod,
phases, phases,
pycompat, pycompat,
scmutil,
util, util,
) )
from mercurial.utils import dateutil from mercurial.utils import dateutil
stringio = util.stringio stringio = util.stringio
from . import common from . import common
raise error.Abort( raise error.Abort(
_( _(
b'hg.revs cannot be combined with ' b'hg.revs cannot be combined with '
b'hg.startrev or --rev' b'hg.startrev or --rev'
) )
) )
nodes = set() nodes = set()
parents = set() parents = set()
for r in scmutil.revrange(self.repo, [hgrevs]): for r in logcmdutil.revrange(self.repo, [hgrevs]):
ctx = self.repo[r] ctx = self.repo[r]
nodes.add(ctx.node()) nodes.add(ctx.node())
parents.update(p.node() for p in ctx.parents()) parents.update(p.node() for p in ctx.parents())
self.keep = nodes.__contains__ self.keep = nodes.__contains__
self._heads = nodes - parents self._heads = nodes - parents
def _changectx(self, rev): def _changectx(self, rev):
if self.lastrev != rev: if self.lastrev != rev:

hgext/fastexport.py

from __future__ import absolute_import from __future__ import absolute_import
import re import re
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import hex, nullrev from mercurial.node import hex, nullrev
from mercurial.utils import stringutil from mercurial.utils import stringutil
from mercurial import ( from mercurial import (
error, error,
logcmdutil,
pycompat, pycompat,
registrar, registrar,
scmutil, scmutil,
) )
from .convert import convcmd from .convert import convcmd
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
Incremental dumps can be created by using marks files. Incremental dumps can be created by using marks files.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs += tuple(opts.get(b"rev", [])) revs += tuple(opts.get(b"rev", []))
if not revs: if not revs:
revs = scmutil.revrange(repo, [b":"]) revs = scmutil.revrange(repo, [b":"])
else: else:
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
if not revs: if not revs:
raise error.Abort(_(b"no revisions matched")) raise error.Abort(_(b"no revisions matched"))
authorfile = opts.get(b"authormap") authorfile = opts.get(b"authormap")
if authorfile: if authorfile:
authormap = convcmd.readauthormap(ui, authorfile) authormap = convcmd.readauthormap(ui, authorfile)
else: else:
authormap = {} authormap = {}

hgext/fix.py

from mercurial.utils import procutil from mercurial.utils import procutil
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
context, context,
copies, copies,
error, error,
logcmdutil,
match as matchmod, match as matchmod,
mdiff, mdiff,
merge, merge,
mergestate as mergestatemod, mergestate as mergestatemod,
obsolete, obsolete,
pycompat, pycompat,
registrar, registrar,
rewriteutil, rewriteutil,
return workqueue, numitems return workqueue, numitems
def getrevstofix(ui, repo, opts): def getrevstofix(ui, repo, opts):
"""Returns the set of revision numbers that should be fixed""" """Returns the set of revision numbers that should be fixed"""
if opts[b'all']: if opts[b'all']:
revs = repo.revs(b'(not public() and not obsolete()) or wdir()') revs = repo.revs(b'(not public() and not obsolete()) or wdir()')
elif opts[b'source']: elif opts[b'source']:
source_revs = scmutil.revrange(repo, opts[b'source']) source_revs = logcmdutil.revrange(repo, opts[b'source'])
revs = set(repo.revs(b'(%ld::) - obsolete()', source_revs)) revs = set(repo.revs(b'(%ld::) - obsolete()', source_revs))
if wdirrev in source_revs: if wdirrev in source_revs:
# `wdir()::` is currently empty, so manually add wdir # `wdir()::` is currently empty, so manually add wdir
revs.add(wdirrev) revs.add(wdirrev)
if repo[b'.'].rev() in revs: if repo[b'.'].rev() in revs:
revs.add(wdirrev) revs.add(wdirrev)
else: else:
revs = set(scmutil.revrange(repo, opts[b'rev'])) revs = set(logcmdutil.revrange(repo, opts[b'rev']))
if opts.get(b'working_dir'): if opts.get(b'working_dir'):
revs.add(wdirrev) revs.add(wdirrev)
for rev in revs: for rev in revs:
checkfixablectx(ui, repo, repo[rev]) checkfixablectx(ui, repo, repo[rev])
# Allow fixing only wdir() even if there's an unfinished operation # Allow fixing only wdir() even if there's an unfinished operation
if not (len(revs) == 1 and wdirrev in revs): if not (len(revs) == 1 and wdirrev in revs):
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
rewriteutil.precheck(repo, revs, b'fix') rewriteutil.precheck(repo, revs, b'fix')
The base contexts determine which lines are considered modified when we The base contexts determine which lines are considered modified when we
attempt to fix just the modified lines in a file. It also determines which attempt to fix just the modified lines in a file. It also determines which
files we attempt to fix, so it is important to compute this even when files we attempt to fix, so it is important to compute this even when
--whole is used. --whole is used.
""" """
# The --base flag overrides the usual logic, and we give every revision # The --base flag overrides the usual logic, and we give every revision
# exactly the set of baserevs that the user specified. # exactly the set of baserevs that the user specified.
if opts.get(b'base'): if opts.get(b'base'):
baserevs = set(scmutil.revrange(repo, opts.get(b'base'))) baserevs = set(logcmdutil.revrange(repo, opts.get(b'base')))
if not baserevs: if not baserevs:
baserevs = {nullrev} baserevs = {nullrev}
basectxs = {repo[rev] for rev in baserevs} basectxs = {repo[rev] for rev in baserevs}
return {rev: basectxs for rev in revstofix} return {rev: basectxs for rev in revstofix}
# Proceed in topological order so that we can easily determine each # Proceed in topological order so that we can easily determine each
# revision's baserevs by looking at its parents and their baserevs. # revision's baserevs by looking at its parents and their baserevs.
basectxs = collections.defaultdict(set) basectxs = collections.defaultdict(set)

hgext/histedit.py

defaultrev = destutil.desthistedit(ui, repo) defaultrev = destutil.desthistedit(ui, repo)
if defaultrev is not None: if defaultrev is not None:
revs.append(defaultrev) revs.append(defaultrev)
if len(revs) != 1: if len(revs) != 1:
raise error.InputError( raise error.InputError(
_(b'histedit requires exactly one ancestor revision') _(b'histedit requires exactly one ancestor revision')
) )
rr = list(repo.set(b'roots(%ld)', scmutil.revrange(repo, revs))) rr = list(repo.set(b'roots(%ld)', logcmdutil.revrange(repo, revs)))
if len(rr) != 1: if len(rr) != 1:
raise error.InputError( raise error.InputError(
_( _(
b'The specified revisions must have ' b'The specified revisions must have '
b'exactly one common root' b'exactly one common root'
) )
) )
root = rr[0].node() root = rr[0].node()
nobackup = not ui.configbool(b'rewrite', b'backup-bundle') nobackup = not ui.configbool(b'rewrite', b'backup-bundle')
rules = opts.get(b'commands', b'') rules = opts.get(b'commands', b'')
state.keep = opts.get(b'keep', False) state.keep = opts.get(b'keep', False)
_validateargs(ui, repo, freeargs, opts, goal, rules, revs) _validateargs(ui, repo, freeargs, opts, goal, rules, revs)
hastags = False hastags = False
if revs: if revs:
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
ctxs = [repo[rev] for rev in revs] ctxs = [repo[rev] for rev in revs]
for ctx in ctxs: for ctx in ctxs:
tags = [tag for tag in ctx.tags() if tag != b'tip'] tags = [tag for tag in ctx.tags() if tag != b'tip']
if not hastags: if not hastags:
hastags = len(tags) hastags = len(tags)
if hastags: if hastags:
if ui.promptchoice( if ui.promptchoice(
_( _(
topmost = repo.dirstate.p1() topmost = repo.dirstate.p1()
if outg: if outg:
if freeargs: if freeargs:
remote = freeargs[0] remote = freeargs[0]
else: else:
remote = None remote = None
root = findoutgoing(ui, repo, remote, force, opts) root = findoutgoing(ui, repo, remote, force, opts)
else: else:
rr = list(repo.set(b'roots(%ld)', scmutil.revrange(repo, revs))) rr = list(repo.set(b'roots(%ld)', logcmdutil.revrange(repo, revs)))
if len(rr) != 1: if len(rr) != 1:
raise error.InputError( raise error.InputError(
_( _(
b'The specified revisions must have ' b'The specified revisions must have '
b'exactly one common root' b'exactly one common root'
) )
) )
root = rr[0].node() root = rr[0].node()

hgext/largefiles/lfcommands.py

from mercurial import ( from mercurial import (
cmdutil, cmdutil,
context, context,
error, error,
exthelper, exthelper,
hg, hg,
lock, lock,
logcmdutil,
match as matchmod, match as matchmod,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.utils import hashutil from mercurial.utils import hashutil
from ..convert import ( from ..convert import (
hg lfpull -r "branch(default)" hg lfpull -r "branch(default)"
""" """
repo.lfpullsource = source repo.lfpullsource = source
revs = opts.get('rev', []) revs = opts.get('rev', [])
if not revs: if not revs:
raise error.Abort(_(b'no revisions specified')) raise error.Abort(_(b'no revisions specified'))
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
numcached = 0 numcached = 0
for rev in revs: for rev in revs:
ui.note(_(b'pulling largefiles for revision %d\n') % rev) ui.note(_(b'pulling largefiles for revision %d\n') % rev)
(cached, missing) = cachelfiles(ui, repo, rev) (cached, missing) = cachelfiles(ui, repo, rev)
numcached += len(cached) numcached += len(cached)
ui.status(_(b"%d largefiles cached\n") % numcached) ui.status(_(b"%d largefiles cached\n") % numcached)
@eh.command(b'debuglfput', [] + cmdutil.remoteopts, _(b'FILE')) @eh.command(b'debuglfput', [] + cmdutil.remoteopts, _(b'FILE'))
def debuglfput(ui, repo, filepath, **kwargs): def debuglfput(ui, repo, filepath, **kwargs):
hash = lfutil.hashfile(filepath) hash = lfutil.hashfile(filepath)
storefactory.openstore(repo).put(filepath, hash) storefactory.openstore(repo).put(filepath, hash)
ui.write(b'%s\n' % hash) ui.write(b'%s\n' % hash)
return 0 return 0

hgext/largefiles/overrides.py

revspostpull = len(repo) revspostpull = len(repo)
lfrevs = opts.get('lfrev', []) lfrevs = opts.get('lfrev', [])
if opts.get('all_largefiles'): if opts.get('all_largefiles'):
lfrevs.append(b'pulled()') lfrevs.append(b'pulled()')
if lfrevs and revspostpull > revsprepull: if lfrevs and revspostpull > revsprepull:
numcached = 0 numcached = 0
repo.firstpulled = revsprepull # for pulled() revset expression repo.firstpulled = revsprepull # for pulled() revset expression
try: try:
for rev in scmutil.revrange(repo, lfrevs): for rev in logcmdutil.revrange(repo, lfrevs):
ui.note(_(b'pulling largefiles for revision %d\n') % rev) ui.note(_(b'pulling largefiles for revision %d\n') % rev)
(cached, missing) = lfcommands.cachelfiles(ui, repo, rev) (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
numcached += len(cached) numcached += len(cached)
finally: finally:
del repo.firstpulled del repo.firstpulled
ui.status(_(b"%d largefiles cached\n") % numcached) ui.status(_(b"%d largefiles cached\n") % numcached)
return result return result
) )
], ],
) )
def overridepush(orig, ui, repo, *args, **kwargs): def overridepush(orig, ui, repo, *args, **kwargs):
"""Override push command and store --lfrev parameters in opargs""" """Override push command and store --lfrev parameters in opargs"""
lfrevs = kwargs.pop('lfrev', None) lfrevs = kwargs.pop('lfrev', None)
if lfrevs: if lfrevs:
opargs = kwargs.setdefault('opargs', {}) opargs = kwargs.setdefault('opargs', {})
opargs[b'lfrevs'] = scmutil.revrange(repo, lfrevs) opargs[b'lfrevs'] = logcmdutil.revrange(repo, lfrevs)
return orig(ui, repo, *args, **kwargs) return orig(ui, repo, *args, **kwargs)
@eh.wrapfunction(exchange, b'pushoperation') @eh.wrapfunction(exchange, b'pushoperation')
def exchangepushoperation(orig, *args, **kwargs): def exchangepushoperation(orig, *args, **kwargs):
"""Override pushoperation constructor and store lfrevs parameter""" """Override pushoperation constructor and store lfrevs parameter"""
lfrevs = kwargs.pop('lfrevs', None) lfrevs = kwargs.pop('lfrevs', None)
pushop = orig(*args, **kwargs) pushop = orig(*args, **kwargs)

hgext/lfs/__init__.py

config, config,
context, context,
error, error,
extensions, extensions,
exthelper, exthelper,
filelog, filelog,
filesetlang, filesetlang,
localrepo, localrepo,
logcmdutil,
minifileset, minifileset,
pycompat, pycompat,
revlog, revlog,
scmutil, scmutil,
templateutil, templateutil,
util, util,
) )
@eh.command( @eh.command(
b'debuglfsupload', b'debuglfsupload',
[(b'r', b'rev', [], _(b'upload large files introduced by REV'))], [(b'r', b'rev', [], _(b'upload large files introduced by REV'))],
) )
def debuglfsupload(ui, repo, **opts): def debuglfsupload(ui, repo, **opts):
"""upload lfs blobs added by the working copy parent or given revisions""" """upload lfs blobs added by the working copy parent or given revisions"""
revs = opts.get('rev', []) revs = opts.get('rev', [])
pointers = wrapper.extractpointers(repo, scmutil.revrange(repo, revs)) pointers = wrapper.extractpointers(repo, logcmdutil.revrange(repo, revs))
wrapper.uploadblobs(repo, pointers) wrapper.uploadblobs(repo, pointers)
@eh.wrapcommand( @eh.wrapcommand(
b'verify', b'verify',
opts=[(b'', b'no-lfs', None, _(b'skip missing lfs blob content'))], opts=[(b'', b'no-lfs', None, _(b'skip missing lfs blob content'))],
) )
def verify(orig, ui, repo, **opts): def verify(orig, ui, repo, **opts):

hgext/mq.py

raise error.Abort(_(b"patch %s not in series file") % patch) raise error.Abort(_(b"patch %s not in series file") % patch)
if patch not in realpatches: if patch not in realpatches:
realpatches.append(patch) realpatches.append(patch)
numrevs = 0 numrevs = 0
if opts.get(b'rev'): if opts.get(b'rev'):
if not self.applied: if not self.applied:
raise error.Abort(_(b'no patches applied')) raise error.Abort(_(b'no patches applied'))
revs = scmutil.revrange(repo, opts.get(b'rev')) revs = logcmdutil.revrange(repo, opts.get(b'rev'))
revs.sort() revs.sort()
revpatches = self._revpatches(repo, revs) revpatches = self._revpatches(repo, revs)
realpatches += revpatches realpatches += revpatches
numrevs = len(revpatches) numrevs = len(revpatches)
self._cleanup(realpatches, numrevs, opts.get(b'keep')) self._cleanup(realpatches, numrevs, opts.get(b'keep'))
def checktoppatch(self, repo): def checktoppatch(self, repo):
_(b'patch %s is already in the series file') % patchname _(b'patch %s is already in the series file') % patchname
) )
if rev: if rev:
if files: if files:
raise error.Abort( raise error.Abort(
_(b'option "-r" not valid when importing files') _(b'option "-r" not valid when importing files')
) )
rev = scmutil.revrange(repo, rev) rev = logcmdutil.revrange(repo, rev)
rev.sort(reverse=True) rev.sort(reverse=True)
elif not files: elif not files:
raise error.Abort(_(b'no files or revisions specified')) raise error.Abort(_(b'no files or revisions specified'))
if (len(files) > 1 or len(rev) > 1) and patchname: if (len(files) > 1 or len(rev) > 1) and patchname:
raise error.Abort( raise error.Abort(
_(b'option "-n" not valid when importing multiple patches') _(b'option "-n" not valid when importing multiple patches')
) )
imported = [] imported = []
elif opts.get('applied'): elif opts.get('applied'):
revrange = (b'qbase::qtip',) + revrange revrange = (b'qbase::qtip',) + revrange
q = repo.mq q = repo.mq
if not q.applied: if not q.applied:
ui.status(_(b'no patches applied\n')) ui.status(_(b'no patches applied\n'))
return 0 return 0
revs = scmutil.revrange(repo, revrange) revs = logcmdutil.revrange(repo, revrange)
if repo[b'.'].rev() in revs and repo[None].files(): if repo[b'.'].rev() in revs and repo[None].files():
ui.warn(_(b'warning: uncommitted changes in the working directory\n')) ui.warn(_(b'warning: uncommitted changes in the working directory\n'))
# queue.finish may changes phases but leave the responsibility to lock the # queue.finish may changes phases but leave the responsibility to lock the
# repo to the caller to avoid deadlock with wlock. This command code is # repo to the caller to avoid deadlock with wlock. This command code is
# responsibility for this locking. # responsibility for this locking.
with repo.lock(): with repo.lock():
q.finish(repo, revs) q.finish(repo, revs)
q.savedirty() q.savedirty()

hgext/patchbomb.py

from mercurial.node import bin from mercurial.node import bin
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
commands, commands,
encoding, encoding,
error, error,
formatter, formatter,
hg, hg,
logcmdutil,
mail, mail,
patch, patch,
pycompat, pycompat,
registrar, registrar,
scmutil, scmutil,
templater, templater,
util, util,
) )
if revs: if revs:
raise error.Abort(_(b'use only one form to specify the revision')) raise error.Abort(_(b'use only one form to specify the revision'))
revs = rev revs = rev
elif bookmark: elif bookmark:
if bookmark not in repo._bookmarks: if bookmark not in repo._bookmarks:
raise error.Abort(_(b"bookmark '%s' not found") % bookmark) raise error.Abort(_(b"bookmark '%s' not found") % bookmark)
revs = scmutil.bookmarkrevs(repo, bookmark) revs = scmutil.bookmarkrevs(repo, bookmark)
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
if outgoing: if outgoing:
revs = _getoutgoing(repo, dest, revs) revs = _getoutgoing(repo, dest, revs)
if bundle: if bundle:
opts[b'revs'] = [b"%d" % r for r in revs] opts[b'revs'] = [b"%d" % r for r in revs]
# check if revision exist on the public destination # check if revision exist on the public destination
publicurl = repo.ui.config(b'patchbomb', b'publicurl') publicurl = repo.ui.config(b'patchbomb', b'publicurl')
if publicurl: if publicurl:

hgext/phabricator.py

as if diffed from the parent of the first revision to the last. The commit as if diffed from the parent of the first revision to the last. The commit
messages are concatenated in the summary field on Phabricator. messages are concatenated in the summary field on Phabricator.
phabsend will check obsstore and the above association to decide whether to phabsend will check obsstore and the above association to decide whether to
update an existing Differential Revision, or create a new one. update an existing Differential Revision, or create a new one.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs = list(revs) + opts.get(b'rev', []) revs = list(revs) + opts.get(b'rev', [])
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
revs.sort() # ascending order to preserve topological parent/child in phab revs.sort() # ascending order to preserve topological parent/child in phab
if not revs: if not revs:
raise error.Abort(_(b'phabsend requires at least one changeset')) raise error.Abort(_(b'phabsend requires at least one changeset'))
if opts.get(b'amend'): if opts.get(b'amend'):
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
ctxs = [repo[rev] for rev in revs] ctxs = [repo[rev] for rev in revs]
revs = opts.get(b'rev') revs = opts.get(b'rev')
if revs: if revs:
if not repo: if not repo:
raise error.InputError(_(b'--rev requires a repository')) raise error.InputError(_(b'--rev requires a repository'))
if specs: if specs:
raise error.InputError(_(b'cannot specify both DREVSPEC and --rev')) raise error.InputError(_(b'cannot specify both DREVSPEC and --rev'))
drevmap = getdrevmap(repo, scmutil.revrange(repo, [revs])) drevmap = getdrevmap(repo, logcmdutil.revrange(repo, [revs]))
specs = [] specs = []
unknown = [] unknown = []
for r, d in pycompat.iteritems(drevmap): for r, d in pycompat.iteritems(drevmap):
if d is None: if d is None:
unknown.append(repo[r]) unknown.append(repo[r])
else: else:
specs.append(b'D%d' % d) specs.append(b'D%d' % d)
if unknown: if unknown:

hgext/rebase.py

bookmarks, bookmarks,
cmdutil, cmdutil,
commands, commands,
copies, copies,
destutil, destutil,
dirstateguard, dirstateguard,
error, error,
extensions, extensions,
logcmdutil,
merge as mergemod, merge as mergemod,
mergestate as mergestatemod, mergestate as mergestatemod,
mergeutil, mergeutil,
obsolete, obsolete,
obsutil, obsutil,
patch, patch,
phases, phases,
pycompat, pycompat,
raise error.InputError( raise error.InputError(
_(b'you must specify a destination'), _(b'you must specify a destination'),
hint=_(b'use: hg rebase -d REV'), hint=_(b'use: hg rebase -d REV'),
) )
dest = None dest = None
if revf: if revf:
rebaseset = scmutil.revrange(repo, revf) rebaseset = logcmdutil.revrange(repo, revf)
if not rebaseset: if not rebaseset:
ui.status(_(b'empty "rev" revision set - nothing to rebase\n')) ui.status(_(b'empty "rev" revision set - nothing to rebase\n'))
return None return None
elif srcf: elif srcf:
src = scmutil.revrange(repo, srcf) src = logcmdutil.revrange(repo, srcf)
if not src: if not src:
ui.status(_(b'empty "source" revision set - nothing to rebase\n')) ui.status(_(b'empty "source" revision set - nothing to rebase\n'))
return None return None
# `+ (%ld)` to work around `wdir()::` being empty # `+ (%ld)` to work around `wdir()::` being empty
rebaseset = repo.revs(b'(%ld):: + (%ld)', src, src) rebaseset = repo.revs(b'(%ld):: + (%ld)', src, src)
else: else:
base = scmutil.revrange(repo, basef or [b'.']) base = logcmdutil.revrange(repo, basef or [b'.'])
if not base: if not base:
ui.status( ui.status(
_(b'empty "base" revision set - ' b"can't compute rebase set\n") _(b'empty "base" revision set - ' b"can't compute rebase set\n")
) )
return None return None
if destf: if destf:
# --base does not support multiple destinations # --base does not support multiple destinations
dest = scmutil.revsingle(repo, destf) dest = scmutil.revsingle(repo, destf)

hgext/releasenotes.py

from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial.node import hex from mercurial.node import hex
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
config, config,
error, error,
logcmdutil,
minirst, minirst,
pycompat, pycompat,
registrar, registrar,
scmutil,
util, util,
) )
from mercurial.utils import ( from mercurial.utils import (
procutil, procutil,
stringutil, stringutil,
) )
cmdtable = {} cmdtable = {}
sections = releasenotessections(ui, repo) sections = releasenotessections(ui, repo)
cmdutil.check_incompatible_arguments(opts, b'list', [b'rev', b'check']) cmdutil.check_incompatible_arguments(opts, b'list', [b'rev', b'check'])
if opts.get(b'list'): if opts.get(b'list'):
return _getadmonitionlist(ui, sections) return _getadmonitionlist(ui, sections)
rev = opts.get(b'rev') rev = opts.get(b'rev')
revs = scmutil.revrange(repo, [rev or b'not public()']) revs = logcmdutil.revrange(repo, [rev or b'not public()'])
if opts.get(b'check'): if opts.get(b'check'):
return checkadmonitions(ui, repo, sections.names(), revs) return checkadmonitions(ui, repo, sections.names(), revs)
incoming = parsenotesfromrevisions(repo, sections.names(), revs) incoming = parsenotesfromrevisions(repo, sections.names(), revs)
if file_ is None: if file_ is None:
ui.pager(b'releasenotes') ui.pager(b'releasenotes')
return ui.write(serializenotes(sections, incoming)) return ui.write(serializenotes(sections, incoming))

hgext/split.py

) )
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
cmdutil, cmdutil,
commands, commands,
error, error,
hg, hg,
logcmdutil,
pycompat, pycompat,
registrar, registrar,
revsetlang, revsetlang,
rewriteutil, rewriteutil,
scmutil, scmutil,
util, util,
) )
if opts.get(b'rev'): if opts.get(b'rev'):
revlist.append(opts.get(b'rev')) revlist.append(opts.get(b'rev'))
revlist.extend(revs) revlist.extend(revs)
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
tr = repo.transaction(b'split') tr = repo.transaction(b'split')
# If the rebase somehow runs into conflicts, make sure # If the rebase somehow runs into conflicts, make sure
# we close the transaction so the user can continue it. # we close the transaction so the user can continue it.
with util.acceptintervention(tr): with util.acceptintervention(tr):
revs = scmutil.revrange(repo, revlist or [b'.']) revs = logcmdutil.revrange(repo, revlist or [b'.'])
if len(revs) > 1: if len(revs) > 1:
raise error.InputError(_(b'cannot split multiple revisions')) raise error.InputError(_(b'cannot split multiple revisions'))
rev = revs.first() rev = revs.first()
# Handle nullrev specially here (instead of leaving for precheck() # Handle nullrev specially here (instead of leaving for precheck()
# below) so we get a nicer message and error code. # below) so we get a nicer message and error code.
if rev is None or rev == nullrev: if rev is None or rev == nullrev:
ui.status(_(b'nothing to split\n')) ui.status(_(b'nothing to split\n'))

hgext/transplant.py

hg, hg,
logcmdutil, logcmdutil,
match, match,
merge, merge,
patch, patch,
pycompat, pycompat,
registrar, registrar,
revset, revset,
scmutil,
smartset, smartset,
state as statemod, state as statemod,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from mercurial.utils import ( from mercurial.utils import (
procutil, procutil,
stringutil, stringutil,
if opts.get(b'continue'): if opts.get(b'continue'):
tp.resume(repo, source, opts) tp.resume(repo, source, opts)
return return
tf = tp.transplantfilter(repo, source, p1) tf = tp.transplantfilter(repo, source, p1)
if opts.get(b'prune'): if opts.get(b'prune'):
prune = { prune = {
source[r].node() source[r].node()
for r in scmutil.revrange(source, opts.get(b'prune')) for r in logcmdutil.revrange(source, opts.get(b'prune'))
} }
matchfn = lambda x: tf(x) and x not in prune matchfn = lambda x: tf(x) and x not in prune
else: else:
matchfn = tf matchfn = tf
merges = pycompat.maplist(source.lookup, opts.get(b'merge', ())) merges = pycompat.maplist(source.lookup, opts.get(b'merge', ()))
revmap = {} revmap = {}
if revs: if revs:
for r in scmutil.revrange(source, revs): for r in logcmdutil.revrange(source, revs):
revmap[int(r)] = source[r].node() revmap[int(r)] = source[r].node()
elif opts.get(b'all') or not merges: elif opts.get(b'all') or not merges:
if source != repo: if source != repo:
alltransplants = incwalk(source, csets, match=matchfn) alltransplants = incwalk(source, csets, match=matchfn)
else: else:
alltransplants = transplantwalk( alltransplants = transplantwalk(
source, p1, heads, match=matchfn source, p1, heads, match=matchfn
) )

mercurial/cmdutil.py

def changebranch(ui, repo, revs, label, opts): def changebranch(ui, repo, revs, label, opts):
"""Change the branch name of given revs to label""" """Change the branch name of given revs to label"""
with repo.wlock(), repo.lock(), repo.transaction(b'branches'): with repo.wlock(), repo.lock(), repo.transaction(b'branches'):
# abort in case of uncommitted merge or dirty wdir # abort in case of uncommitted merge or dirty wdir
bailifchanged(repo) bailifchanged(repo)
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
if not revs: if not revs:
raise error.InputError(b"empty revision set") raise error.InputError(b"empty revision set")
roots = repo.revs(b'roots(%ld)', revs) roots = repo.revs(b'roots(%ld)', revs)
if len(roots) > 1: if len(roots) > 1:
raise error.InputError( raise error.InputError(
_(b"cannot change branch of non-linear revisions") _(b"cannot change branch of non-linear revisions")
) )
rewriteutil.precheck(repo, revs, b'change branch of') rewriteutil.precheck(repo, revs, b'change branch of')

mercurial/commands.py

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
m = scmutil.match(ctx, pats, opts, badfn=bad) m = scmutil.match(ctx, pats, opts, badfn=bad)
follow = not opts.get(b'no_follow') follow = not opts.get(b'no_follow')
diffopts = patch.difffeatureopts( diffopts = patch.difffeatureopts(
ui, opts, section=b'annotate', whitespace=True ui, opts, section=b'annotate', whitespace=True
) )
skiprevs = opts.get(b'skip') skiprevs = opts.get(b'skip')
if skiprevs: if skiprevs:
skiprevs = scmutil.revrange(repo, skiprevs) skiprevs = logcmdutil.revrange(repo, skiprevs)
uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True) uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
for abs in ctx.walk(m): for abs in ctx.walk(m):
fctx = ctx[abs] fctx = ctx[abs]
rootfm.startitem() rootfm.startitem()
rootfm.data(path=abs) rootfm.data(path=abs)
if not opts.get(b'text') and fctx.isbinary(): if not opts.get(b'text') and fctx.isbinary():
rootfm.plain(_(b"%s: binary file\n") % uipathfn(abs)) rootfm.plain(_(b"%s: binary file\n") % uipathfn(abs))
if reset: if reset:
hbisect.resetstate(repo) hbisect.resetstate(repo)
return return
state = hbisect.load_state(repo) state = hbisect.load_state(repo)
if rev: if rev:
nodes = [repo[i].node() for i in scmutil.revrange(repo, rev)] nodes = [repo[i].node() for i in logcmdutil.revrange(repo, rev)]
else: else:
nodes = [repo.lookup(b'.')] nodes = [repo.lookup(b'.')]
# update state # update state
if good or bad or skip: if good or bad or skip:
if good: if good:
state[b'good'] += nodes state[b'good'] += nodes
elif bad: elif bad:
Returns 0. Returns 0.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs = opts.get(b'rev') revs = opts.get(b'rev')
selectedbranches = None selectedbranches = None
if revs: if revs:
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
getbi = repo.revbranchcache().branchinfo getbi = repo.revbranchcache().branchinfo
selectedbranches = {getbi(r)[0] for r in revs} selectedbranches = {getbi(r)[0] for r in revs}
ui.pager(b'branches') ui.pager(b'branches')
fm = ui.formatter(b'branches', opts) fm = ui.formatter(b'branches', opts)
hexfunc = fm.hexfunc hexfunc = fm.hexfunc
allheads = set(repo.heads()) allheads = set(repo.heads())
permissions, copy/rename information, and revision history. permissions, copy/rename information, and revision history.
Returns 0 on success, 1 if no changes found. Returns 0 on success, 1 if no changes found.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs = None revs = None
if b'rev' in opts: if b'rev' in opts:
revstrings = opts[b'rev'] revstrings = opts[b'rev']
revs = scmutil.revrange(repo, revstrings) revs = logcmdutil.revrange(repo, revstrings)
if revstrings and not revs: if revstrings and not revs:
raise error.InputError(_(b'no commits to bundle')) raise error.InputError(_(b'no commits to bundle'))
bundletype = opts.get(b'type', b'bzip2').lower() bundletype = opts.get(b'type', b'bzip2').lower()
try: try:
bundlespec = bundlecaches.parsebundlespec( bundlespec = bundlecaches.parsebundlespec(
repo, bundletype, strict=False repo, bundletype, strict=False
) )
if dests: if dests:
raise error.InputError( raise error.InputError(
_(b"--all is incompatible with specifying destinations") _(b"--all is incompatible with specifying destinations")
) )
if opts.get(b'base'): if opts.get(b'base'):
ui.warn(_(b"ignoring --base because --all was specified\n")) ui.warn(_(b"ignoring --base because --all was specified\n"))
base = [nullrev] base = [nullrev]
else: else:
base = scmutil.revrange(repo, opts.get(b'base')) base = logcmdutil.revrange(repo, opts.get(b'base'))
if cgversion not in changegroup.supportedoutgoingversions(repo): if cgversion not in changegroup.supportedoutgoingversions(repo):
raise error.Abort( raise error.Abort(
_(b"repository does not support bundle version %s") % cgversion _(b"repository does not support bundle version %s") % cgversion
) )
if base: if base:
if dests: if dests:
raise error.InputError( raise error.InputError(
raise error.InputError(_(b"bookmark '%s' not found") % bookmark) raise error.InputError(_(b"bookmark '%s' not found") % bookmark)
revs = scmutil.bookmarkrevs(repo, bookmark) revs = scmutil.bookmarkrevs(repo, bookmark)
else: else:
if not changesets: if not changesets:
changesets = [b'.'] changesets = [b'.']
repo = scmutil.unhidehashlikerevs(repo, changesets, b'nowarn') repo = scmutil.unhidehashlikerevs(repo, changesets, b'nowarn')
revs = scmutil.revrange(repo, changesets) revs = logcmdutil.revrange(repo, changesets)
if not revs: if not revs:
raise error.InputError(_(b"export requires at least one changeset")) raise error.InputError(_(b"export requires at least one changeset"))
if len(revs) > 1: if len(revs) > 1:
ui.note(_(b'exporting patches:\n')) ui.note(_(b'exporting patches:\n'))
else: else:
ui.note(_(b'exporting patch:\n')) ui.note(_(b'exporting patch:\n'))
revs = [repo[node].rev() for node in nodes] revs = [repo[node].rev() for node in nodes]
else: else:
cmdutil.wrongtooltocontinue(repo, _(b'graft')) cmdutil.wrongtooltocontinue(repo, _(b'graft'))
else: else:
if not revs: if not revs:
raise error.InputError(_(b'no revisions specified')) raise error.InputError(_(b'no revisions specified'))
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
skipped = set() skipped = set()
basectx = None basectx = None
if opts.get('base'): if opts.get('base'):
basectx = scmutil.revsingle(repo, opts['base'], None) basectx = scmutil.revsingle(repo, opts['base'], None)
if basectx is None: if basectx is None:
# check for merges # check for merges
for rev in repo.revs(b'%ld and merge()', revs): for rev in repo.revs(b'%ld and merge()', revs):
else: else:
heads = [] heads = []
for branch in repo.branchmap(): for branch in repo.branchmap():
heads += repo.branchheads(branch, start, opts.get(b'closed')) heads += repo.branchheads(branch, start, opts.get(b'closed'))
heads = [repo[h] for h in heads] heads = [repo[h] for h in heads]
if branchrevs: if branchrevs:
branches = { branches = {
repo[r].branch() for r in scmutil.revrange(repo, branchrevs) repo[r].branch() for r in logcmdutil.revrange(repo, branchrevs)
} }
heads = [h for h in heads if h.branch() in branches] heads = [h for h in heads if h.branch() in branches]
if opts.get(b'active') and branchrevs: if opts.get(b'active') and branchrevs:
dagheads = repo.heads(start) dagheads = repo.heads(start)
heads = [h for h in heads if h.node() in dagheads] heads = [h for h in heads if h.node() in dagheads]
if branchrevs: if branchrevs:
if targetphase is not None: if targetphase is not None:
raise error.InputError(_(b'only one phase can be specified')) raise error.InputError(_(b'only one phase can be specified'))
targetphase = idx targetphase = idx
# look for specified revision # look for specified revision
revs = list(revs) revs = list(revs)
revs.extend(opts[b'rev']) revs.extend(opts[b'rev'])
if revs: if revs:
revs = scmutil.revrange(repo, revs) revs = logcmdutil.revrange(repo, revs)
else: else:
# display both parents as the second parent phase can influence # display both parents as the second parent phase can influence
# the phase of a merge commit # the phase of a merge commit
revs = [c.rev() for c in repo[None].parents()] revs = [c.rev() for c in repo[None].parents()]
ret = 0 ret = 0
if targetphase is None: if targetphase is None:
# display # display
ui.status(_(b'pushing to %s\n') % urlutil.hidepassword(dest)) ui.status(_(b'pushing to %s\n') % urlutil.hidepassword(dest))
revs, checkout = hg.addbranchrevs( revs, checkout = hg.addbranchrevs(
repo, repo, branches, opts.get(b'rev') repo, repo, branches, opts.get(b'rev')
) )
other = hg.peer(repo, opts, dest) other = hg.peer(repo, opts, dest)
try: try:
if revs: if revs:
revs = [repo[r].node() for r in scmutil.revrange(repo, revs)] revs = [repo[r].node() for r in logcmdutil.revrange(repo, revs)]
if not revs: if not revs:
raise error.InputError( raise error.InputError(
_(b"specified revisions evaluate to an empty set"), _(b"specified revisions evaluate to an empty set"),
hint=_(b"use different revision arguments"), hint=_(b"use different revision arguments"),
) )
elif path.pushrev: elif path.pushrev:
# It doesn't make any sense to specify ancestor revisions. So limit # It doesn't make any sense to specify ancestor revisions. So limit
# to DAG heads to make discovery simpler. # to DAG heads to make discovery simpler.

mercurial/debugcommands.py

remoteurl, branches = urlutil.get_unique_pull_path( remoteurl, branches = urlutil.get_unique_pull_path(
b'debugdiscovery', repo, ui, remoteurl b'debugdiscovery', repo, ui, remoteurl
) )
remote = hg.peer(repo, opts, remoteurl) remote = hg.peer(repo, opts, remoteurl)
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl))
else: else:
branches = (None, []) branches = (None, [])
remote_filtered_revs = scmutil.revrange( remote_filtered_revs = logcmdutil.revrange(
unfi, [b"not (::(%s))" % remote_revs] unfi, [b"not (::(%s))" % remote_revs]
) )
remote_filtered_revs = frozenset(remote_filtered_revs) remote_filtered_revs = frozenset(remote_filtered_revs)
def remote_func(x): def remote_func(x):
return remote_filtered_revs return remote_filtered_revs
repoview.filtertable[b'debug-discovery-remote-filter'] = remote_func repoview.filtertable[b'debug-discovery-remote-filter'] = remote_func
remote = repo.peer() remote = repo.peer()
remote._repo = remote._repo.filtered(b'debug-discovery-remote-filter') remote._repo = remote._repo.filtered(b'debug-discovery-remote-filter')
if local_revs: if local_revs:
local_filtered_revs = scmutil.revrange( local_filtered_revs = logcmdutil.revrange(
unfi, [b"not (::(%s))" % local_revs] unfi, [b"not (::(%s))" % local_revs]
) )
local_filtered_revs = frozenset(local_filtered_revs) local_filtered_revs = frozenset(local_filtered_revs)
def local_func(x): def local_func(x):
return local_filtered_revs return local_filtered_revs
repoview.filtertable[b'debug-discovery-local-filter'] = local_func repoview.filtertable[b'debug-discovery-local-filter'] = local_func
common = {clnode(r) for r in common} common = {clnode(r) for r in common}
return common, hds return common, hds
else: else:
def doit(pushedrevs, remoteheads, remote=remote): def doit(pushedrevs, remoteheads, remote=remote):
nodes = None nodes = None
if pushedrevs: if pushedrevs:
revs = scmutil.revrange(repo, pushedrevs) revs = logcmdutil.revrange(repo, pushedrevs)
nodes = [repo[r].node() for r in revs] nodes = [repo[r].node() for r in revs]
common, any, hds = setdiscovery.findcommonheads( common, any, hds = setdiscovery.findcommonheads(
ui, repo, remote, ancestorsof=nodes, audit=data ui, repo, remote, ancestorsof=nodes, audit=data
) )
return common, hds return common, hds
remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None) remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
localrevs = opts[b'rev'] localrevs = opts[b'rev']
_(b'bad obsmarker input: %s') % stringutil.forcebytestr(exc) _(b'bad obsmarker input: %s') % stringutil.forcebytestr(exc)
) )
finally: finally:
tr.release() tr.release()
finally: finally:
l.release() l.release()
else: else:
if opts[b'rev']: if opts[b'rev']:
revs = scmutil.revrange(repo, opts[b'rev']) revs = logcmdutil.revrange(repo, opts[b'rev'])
nodes = [repo[r].node() for r in revs] nodes = [repo[r].node() for r in revs]
markers = list( markers = list(
obsutil.getmarkers( obsutil.getmarkers(
repo, nodes=nodes, exclusive=opts[b'exclusive'] repo, nodes=nodes, exclusive=opts[b'exclusive']
) )
) )
markers.sort(key=lambda x: x._data) markers.sort(key=lambda x: x._data)
else: else:
Here rev2 has two possible (i.e. divergent) successors sets. The first Here rev2 has two possible (i.e. divergent) successors sets. The first
holds one element, whereas the second holds three (i.e. the changeset has holds one element, whereas the second holds three (i.e. the changeset has
been split). been split).
""" """
# passed to successorssets caching computation from one call to another # passed to successorssets caching computation from one call to another
cache = {} cache = {}
ctx2str = bytes ctx2str = bytes
node2str = short node2str = short
for rev in scmutil.revrange(repo, revs): for rev in logcmdutil.revrange(repo, revs):
ctx = repo[rev] ctx = repo[rev]
ui.write(b'%s\n' % ctx2str(ctx)) ui.write(b'%s\n' % ctx2str(ctx))
for succsset in obsutil.successorssets( for succsset in obsutil.successorssets(
repo, ctx.node(), closest=opts['closest'], cache=cache repo, ctx.node(), closest=opts['closest'], cache=cache
): ):
if succsset: if succsset:
ui.write(b' ') ui.write(b' ')
ui.write(node2str(succsset[0])) ui.write(node2str(succsset[0]))
Use --verbose to print the parsed tree. Use --verbose to print the parsed tree.
""" """
revs = None revs = None
if opts['rev']: if opts['rev']:
if repo is None: if repo is None:
raise error.RepoError( raise error.RepoError(
_(b'there is no Mercurial repository here (.hg not found)') _(b'there is no Mercurial repository here (.hg not found)')
) )
revs = scmutil.revrange(repo, opts['rev']) revs = logcmdutil.revrange(repo, opts['rev'])
props = {} props = {}
for d in opts['define']: for d in opts['define']:
try: try:
k, v = (e.strip() for e in d.split(b'=', 1)) k, v = (e.strip() for e in d.split(b'=', 1))
if not k or k == b'ui': if not k or k == b'ui':
raise ValueError raise ValueError
props[k] = v props[k] = v

mercurial/hg.py

p = urlutil.url(dest) p = urlutil.url(dest)
p.path = os.path.normpath(b'%s/%s' % (p.path, subpath)) p.path = os.path.normpath(b'%s/%s' % (p.path, subpath))
dest = bytes(p) dest = bytes(p)
branches = path.branch, opts.get(b'branch') or [] branches = path.branch, opts.get(b'branch') or []
ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(dest)) ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(dest))
revs, checkout = addbranchrevs(repo, repo, branches, opts.get(b'rev')) revs, checkout = addbranchrevs(repo, repo, branches, opts.get(b'rev'))
if revs: if revs:
revs = [repo[rev].node() for rev in scmutil.revrange(repo, revs)] revs = [repo[rev].node() for rev in logcmdutil.revrange(repo, revs)]
other = peer(repo, opts, dest) other = peer(repo, opts, dest)
try: try:
outgoing = discovery.findcommonoutgoing( outgoing = discovery.findcommonoutgoing(
repo, other, revs, force=opts.get(b'force') repo, other, revs, force=opts.get(b'force')
) )
o = outgoing.missing o = outgoing.missing
out.update(o) out.update(o)

mercurial/logcmdutil.py

return smartset.generatorset(revgen(), iterasc=False), filematcher return smartset.generatorset(revgen(), iterasc=False), filematcher
def _makenofollowfilematcher(repo, pats, opts): def _makenofollowfilematcher(repo, pats, opts):
'''hook for extensions to override the filematcher for non-follow cases''' '''hook for extensions to override the filematcher for non-follow cases'''
return None return None
def revrange(repo, specs, localalias=None):
"""Resolves user-provided revset(s).
This just wraps the lower-level scmutil.revrange() in order to raise an
exception indicating user error.
"""
try:
return scmutil.revrange(repo, specs, localalias)
except error.RepoLookupError as e:
raise error.InputError(e.args[0], hint=e.hint)
_opt2logrevset = { _opt2logrevset = {
b'no_merges': (b'not merge()', None), b'no_merges': (b'not merge()', None),
b'only_merges': (b'merge()', None), b'only_merges': (b'merge()', None),
b'_matchfiles': (None, b'_matchfiles(%ps)'), b'_matchfiles': (None, b'_matchfiles(%ps)'),
b'date': (b'date(%s)', None), b'date': (b'date(%s)', None),
b'branch': (b'branch(%s)', b'%lr'), b'branch': (b'branch(%s)', b'%lr'),
b'_patslog': (b'filelog(%s)', b'%lr'), b'_patslog': (b'filelog(%s)', b'%lr'),
b'keyword': (b'keyword(%s)', b'%lr'), b'keyword': (b'keyword(%s)', b'%lr'),
else: else:
expr = None expr = None
return expr return expr
def _initialrevs(repo, wopts): def _initialrevs(repo, wopts):
"""Return the initial set of revisions to be filtered or followed""" """Return the initial set of revisions to be filtered or followed"""
if wopts.revspec: if wopts.revspec:
revs = scmutil.revrange(repo, wopts.revspec) revs = revrange(repo, wopts.revspec)
elif wopts.follow and repo.dirstate.p1() == repo.nullid: elif wopts.follow and repo.dirstate.p1() == repo.nullid:
revs = smartset.baseset() revs = smartset.baseset()
elif wopts.follow: elif wopts.follow:
revs = repo.revs(b'.') revs = repo.revs(b'.')
else: else:
revs = smartset.spanset(repo) revs = smartset.spanset(repo)
revs.reverse() revs.reverse()
return revs return revs

mercurial/strip.py

from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from . import ( from . import (
bookmarks as bookmarksmod, bookmarks as bookmarksmod,
cmdutil, cmdutil,
error, error,
hg, hg,
lock as lockmod, lock as lockmod,
logcmdutil,
mergestate as mergestatemod, mergestate as mergestatemod,
pycompat, pycompat,
registrar, registrar,
repair, repair,
scmutil, scmutil,
util, util,
) )
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
backup = True backup = True
if opts.get(b'no_backup') or opts.get(b'nobackup'): if opts.get(b'no_backup') or opts.get(b'nobackup'):
backup = False backup = False
cl = repo.changelog cl = repo.changelog
revs = list(revs) + opts.get(b'rev') revs = list(revs) + opts.get(b'rev')
revs = set(scmutil.revrange(repo, revs)) revs = set(logcmdutil.revrange(repo, revs))
with repo.wlock(): with repo.wlock():
bookmarks = set(opts.get(b'bookmark')) bookmarks = set(opts.get(b'bookmark'))
if bookmarks: if bookmarks:
repomarks = repo._bookmarks repomarks = repo._bookmarks
if not bookmarks.issubset(repomarks): if not bookmarks.issubset(repomarks):
raise error.Abort( raise error.Abort(
_(b"bookmark '%s' not found") _(b"bookmark '%s' not found")

tests/test-bookmarks.t

date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
summary: 1 summary: 1
but "literal:." is not since "." seems not a literal bookmark: but "literal:." is not since "." seems not a literal bookmark:
$ hg log -r 'bookmark("literal:.")' $ hg log -r 'bookmark("literal:.")'
abort: bookmark '.' does not exist abort: bookmark '.' does not exist
[255] [10]
"." should fail if there's no active bookmark: "." should fail if there's no active bookmark:
$ hg bookmark --inactive $ hg bookmark --inactive
$ hg log -r 'bookmark(.)' $ hg log -r 'bookmark(.)'
abort: no active bookmark abort: no active bookmark
[255] [10]
$ hg log -r 'present(bookmark(.))' $ hg log -r 'present(bookmark(.))'
$ hg log -r 'bookmark(unknown)' $ hg log -r 'bookmark(unknown)'
abort: bookmark 'unknown' does not exist abort: bookmark 'unknown' does not exist
[255] [10]
$ hg log -r 'bookmark("literal:unknown")' $ hg log -r 'bookmark("literal:unknown")'
abort: bookmark 'unknown' does not exist abort: bookmark 'unknown' does not exist
[255] [10]
$ hg log -r 'bookmark("re:unknown")' $ hg log -r 'bookmark("re:unknown")'
$ hg log -r 'present(bookmark("literal:unknown"))' $ hg log -r 'present(bookmark("literal:unknown"))'
$ hg log -r 'present(bookmark("re:unknown"))' $ hg log -r 'present(bookmark("re:unknown"))'
$ hg help revsets | grep 'bookmark(' $ hg help revsets | grep 'bookmark('
"bookmark([name])" "bookmark([name])"
reactivate "X2" reactivate "X2"

tests/test-branch-change.t

changed branch on 1 changesets changed branch on 1 changesets
2 new orphan changesets 2 new orphan changesets
Changing branch of an obsoleted changeset Changing branch of an obsoleted changeset
$ hg branch -r 4 foobar $ hg branch -r 4 foobar
abort: hidden revision '4' was rewritten as: 7c1991464886 abort: hidden revision '4' was rewritten as: 7c1991464886
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
$ hg branch -r 4 --hidden foobar $ hg branch -r 4 --hidden foobar
abort: cannot change branch of 3938acfb5c0f, as that creates content-divergence with 7c1991464886 abort: cannot change branch of 3938acfb5c0f, as that creates content-divergence with 7c1991464886
(add --verbose for details or see 'hg help evolution.instability') (add --verbose for details or see 'hg help evolution.instability')
[10] [10]
Make sure bookmark movement is correct Make sure bookmark movement is correct

tests/test-directaccess.t

Testing read only commands on the hidden revision Testing read only commands on the hidden revision
Testing with rev number Testing with rev number
$ hg exp 2 --config experimental.directaccess.revnums=False $ hg exp 2 --config experimental.directaccess.revnums=False
abort: hidden revision '2' was rewritten as: 2443a0e66469 abort: hidden revision '2' was rewritten as: 2443a0e66469
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
$ hg exp 2 $ hg exp 2
# HG changeset patch # HG changeset patch
# User test # User test
# Date 0 0 # Date 0 0
# Thu Jan 01 00:00:00 1970 +0000 # Thu Jan 01 00:00:00 1970 +0000
# Node ID 28ad74487de9599d00d81085be739c61fc340652 # Node ID 28ad74487de9599d00d81085be739c61fc340652
# Parent 29becc82797a4bc11ec8880b58eaecd2ab3e7760 # Parent 29becc82797a4bc11ec8880b58eaecd2ab3e7760
$ hg log -qr 'null:wdir() & 2147483647' $ hg log -qr 'null:wdir() & 2147483647'
2147483647:ffffffffffff 2147483647:ffffffffffff
Commands with undefined intent 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] [10]
$ hg phase -r 2 $ hg phase -r 2
abort: hidden revision '2' was rewritten as: 2443a0e66469 abort: hidden revision '2' was rewritten as: 2443a0e66469
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
Setting a bookmark will make that changeset unhidden, so this should come in end Setting a bookmark will make that changeset unhidden, so this should come in end
$ hg bookmarks -r 28ad74 book $ hg bookmarks -r 28ad74 book
bookmarking hidden changeset 28ad74487de9 bookmarking hidden changeset 28ad74487de9
(hidden revision '28ad74487de9' was rewritten as: 2443a0e66469) (hidden revision '28ad74487de9' was rewritten as: 2443a0e66469)
$ hg bookmarks $ hg bookmarks
book 2:28ad74487de9 book 2:28ad74487de9

tests/test-export.t

foo-11 foo-11
+line +line
$ hg export "" $ hg export ""
hg: parse error: empty query hg: parse error: empty query
[10] [10]
$ hg export 999 $ hg export 999
abort: unknown revision '999' abort: unknown revision '999'
[255] [10]
$ hg export "not all()" $ hg export "not all()"
abort: export requires at least one changeset abort: export requires at least one changeset
[10] [10]
Check for color output Check for color output
$ cat <<EOF >> $HGRCPATH $ cat <<EOF >> $HGRCPATH
> [color] > [color]
> mode = ansi > mode = ansi

tests/test-log.t

Log on empty repository: checking consistency Log on empty repository: checking consistency
$ hg init empty $ hg init empty
$ cd empty $ cd empty
$ hg log $ hg log
$ hg log -r 1 $ hg log -r 1
abort: unknown revision '1' abort: unknown revision '1'
[255] [10]
$ hg log -r -1:0 $ hg log -r -1:0
abort: unknown revision '-1' abort: unknown revision '-1'
[255] [10]
$ hg log -r 'branch(name)' $ hg log -r 'branch(name)'
abort: unknown revision 'name' abort: unknown revision 'name'
[255] [10]
$ hg log -r null -q $ hg log -r null -q
-1:000000000000 -1:000000000000
$ cd .. $ cd ..
The g is crafted to have 2 filelog topological heads in a linear The g is crafted to have 2 filelog topological heads in a linear
changeset graph changeset graph
$ hg log -r '' $ hg log -r ''
hg: parse error: empty query hg: parse error: empty query
[10] [10]
log -r <some unknown node id> log -r <some unknown node id>
$ hg log -r 1000000000000000000000000000000000000000 $ hg log -r 1000000000000000000000000000000000000000
abort: unknown revision '1000000000000000000000000000000000000000' abort: unknown revision '1000000000000000000000000000000000000000'
[255] [10]
log -k r1 log -k r1
$ hg log -k r1 $ hg log -k r1
changeset: 1:3d5bf5654eda changeset: 1:3d5bf5654eda
user: test user: test
date: Thu Jan 01 00:00:01 1970 +0000 date: Thu Jan 01 00:00:01 1970 +0000
summary: r1 summary: r1
$ hg log --template='{rev}:{node}\n' $ hg log --template='{rev}:{node}\n'
0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05 0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
$ hg log --template='{rev}:{node}\n' --hidden $ hg log --template='{rev}:{node}\n' --hidden
1:a765632148dc55d38c35c4f247c618701886cb2f 1:a765632148dc55d38c35c4f247c618701886cb2f
0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05 0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
$ hg log -r a $ hg log -r a
abort: hidden revision 'a' is pruned abort: hidden revision 'a' is pruned
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
test that parent prevent a changeset to be hidden test that parent prevent a changeset to be hidden
$ hg up 1 -q --hidden $ hg up 1 -q --hidden
updated to hidden changeset a765632148dc updated to hidden changeset a765632148dc
(hidden revision 'a765632148dc' is pruned) (hidden revision 'a765632148dc' is pruned)
$ hg log --template='{rev}:{node}\n' $ hg log --template='{rev}:{node}\n'
1:a765632148dc55d38c35c4f247c618701886cb2f 1:a765632148dc55d38c35c4f247c618701886cb2f
2:94375ec45bddd2a824535fc04855bd058c926ec0 2:94375ec45bddd2a824535fc04855bd058c926ec0
3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e 3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
$ hg log -T'{rev}:{node}\n' -r:tip $ hg log -T'{rev}:{node}\n' -r:tip
2:94375ec45bddd2a824535fc04855bd058c926ec0 2:94375ec45bddd2a824535fc04855bd058c926ec0
3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e 3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
$ hg log -T'{rev}:{node}\n' -r:0 $ hg log -T'{rev}:{node}\n' -r:0
abort: hidden revision '0' is pruned abort: hidden revision '0' is pruned
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
$ hg log -T'{rev}:{node}\n' -f $ hg log -T'{rev}:{node}\n' -f
3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e 3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
2:94375ec45bddd2a824535fc04855bd058c926ec0 2:94375ec45bddd2a824535fc04855bd058c926ec0
clear extensions configuration clear extensions configuration
$ echo '[extensions]' >> $HGRCPATH $ echo '[extensions]' >> $HGRCPATH
$ echo "obs=!" >> $HGRCPATH $ echo "obs=!" >> $HGRCPATH
$ cd .. $ cd ..

tests/test-logexchange.t

o 6:87d6d6676308 default/bar server2/bar o 6:87d6d6676308 default/bar server2/bar
| |
~ ~
Testing for a literal name which does not exists, which should fail. Testing for a literal name which does not exists, which should fail.
$ hg log -r 'remotebranches(def)' -GT "{rev}:{node|short} {remotenames}\n" $ hg log -r 'remotebranches(def)' -GT "{rev}:{node|short} {remotenames}\n"
abort: remote name 'def' does not exist abort: remote name 'def' does not exist
[255] [10]
$ hg log -r 'remotebookmarks("server3")' -GT "{rev}:{node|short} {remotenames}\n" $ hg log -r 'remotebookmarks("server3")' -GT "{rev}:{node|short} {remotenames}\n"
abort: remote name 'server3' does not exist abort: remote name 'server3' does not exist
[255] [10]
$ hg log -r 'remotenames("server3")' -GT "{rev}:{node|short} {remotenames}\n" $ hg log -r 'remotenames("server3")' -GT "{rev}:{node|short} {remotenames}\n"
abort: remote name 'server3' does not exist abort: remote name 'server3' does not exist
[255] [10]
Testing for a pattern which does not match anything, which shouldn't fail. Testing for a pattern which does not match anything, which shouldn't fail.
$ hg log -r 'remotenames("re:^server3$")' $ hg log -r 'remotenames("re:^server3$")'
Testing for multiple names, which is not supported. Testing for multiple names, which is not supported.
$ hg log -r 'remotenames("re:default", "re:server2")' -GT "{rev}:{node|short} {remotenames}\n" $ hg log -r 'remotenames("re:default", "re:server2")' -GT "{rev}:{node|short} {remotenames}\n"

tests/test-mq-qdelete.t

[255] [255]
$ hg qpop $ hg qpop
popping pc popping pc
now at: pb now at: pb
$ hg qfinish -a pc $ hg qfinish -a pc
abort: unknown revision 'pc' abort: unknown revision 'pc'
[255] [10]
$ hg qpush $ hg qpush
applying pc applying pc
patch pc is empty patch pc is empty
now at: pc now at: pc
$ hg qfinish qbase:pb $ hg qfinish qbase:pb
patch pa finalized without changeset message patch pa finalized without changeset message

tests/test-obsolete.t

remote: 3 outgoing remote: 3 outgoing
check that various commands work well with filtering check that various commands work well with filtering
$ hg tip $ hg tip
5:5601fb93a350 (draft) [tip ] add new_3_c 5:5601fb93a350 (draft) [tip ] add new_3_c
$ hg log -r 6 $ hg log -r 6
abort: unknown revision '6' abort: unknown revision '6'
[255] [10]
$ hg log -r 4 $ hg log -r 4
abort: hidden revision '4' was rewritten as: 5601fb93a350 abort: hidden revision '4' was rewritten as: 5601fb93a350
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
$ hg debugrevspec 'rev(6)' $ hg debugrevspec 'rev(6)'
$ hg debugrevspec 'rev(4)' $ hg debugrevspec 'rev(4)'
$ hg debugrevspec 'null' $ hg debugrevspec 'null'
-1 -1
Check that public changeset are not accounted as obsolete: Check that public changeset are not accounted as obsolete:
$ hg --hidden phase --public 2 $ hg --hidden phase --public 2
bookmarking hidden changeset 13bedc178fce bookmarking hidden changeset 13bedc178fce
(hidden revision '13bedc178fce' was rewritten as: a9b1f8652753) (hidden revision '13bedc178fce' was rewritten as: a9b1f8652753)
$ hg log -r 13bedc178fce $ hg log -r 13bedc178fce
4:13bedc178fce (draft *obsolete*) [ bookb] add b [rewritten using amend as 5:a9b1f8652753] 4:13bedc178fce (draft *obsolete*) [ bookb] add b [rewritten using amend as 5:a9b1f8652753]
$ hg book -d bookb $ hg book -d bookb
$ hg log -r 13bedc178fce $ hg log -r 13bedc178fce
abort: hidden revision '13bedc178fce' was rewritten as: a9b1f8652753 abort: hidden revision '13bedc178fce' was rewritten as: a9b1f8652753
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [10]
Empty out the test extension, as it isn't compatible with later parts Empty out the test extension, as it isn't compatible with later parts
of the test. of the test.
$ echo > $TESTTMP/test_extension.py $ echo > $TESTTMP/test_extension.py
Test ability to pull changeset with locally applying obsolescence markers Test ability to pull changeset with locally applying obsolescence markers
(issue4945) (issue4945)

tests/test-revset-legacy-lookup.t

Test label with quote in them. Test label with quote in them.
$ hg tag '"foo"' $ hg tag '"foo"'
$ hg log -r '"foo"' $ hg log -r '"foo"'
2:fb616635b18f Added tag rev(0) for changeset 43114e71eddd ["foo"] 2:fb616635b18f Added tag rev(0) for changeset 43114e71eddd ["foo"]
$ hg log -r '("foo")' $ hg log -r '("foo")'
abort: unknown revision 'foo' abort: unknown revision 'foo'
[255] [10]
$ hg log -r 'revset("foo")' $ hg log -r 'revset("foo")'
abort: unknown revision 'foo' abort: unknown revision 'foo'
[255] [10]
$ hg log -r '("\"foo\"")' $ hg log -r '("\"foo\"")'
2:fb616635b18f Added tag rev(0) for changeset 43114e71eddd ["foo"] 2:fb616635b18f Added tag rev(0) for changeset 43114e71eddd ["foo"]
$ hg log -r 'revset("\"foo\"")' $ hg log -r 'revset("\"foo\"")'
2:fb616635b18f Added tag rev(0) for changeset 43114e71eddd ["foo"] 2:fb616635b18f Added tag rev(0) for changeset 43114e71eddd ["foo"]
Test label with dash in them. Test label with dash in them.
$ hg tag 'foo-bar' $ hg tag 'foo-bar'
Test label with + in them. Test label with + in them.
$ hg tag 'foo+bar' $ hg tag 'foo+bar'
$ hg log -r 'foo+bar' $ hg log -r 'foo+bar'
4:bbf52b87b370 Added tag foo-bar for changeset a50aae922707 [foo+bar] 4:bbf52b87b370 Added tag foo-bar for changeset a50aae922707 [foo+bar]
$ hg log -r '(foo+bar)' $ hg log -r '(foo+bar)'
abort: unknown revision 'foo' abort: unknown revision 'foo'
[255] [10]
$ hg log -r 'revset(foo+bar)' $ hg log -r 'revset(foo+bar)'
abort: unknown revision 'foo' abort: unknown revision 'foo'
[255] [10]
$ hg log -r '"foo+bar"' $ hg log -r '"foo+bar"'
4:bbf52b87b370 Added tag foo-bar for changeset a50aae922707 [foo+bar] 4:bbf52b87b370 Added tag foo-bar for changeset a50aae922707 [foo+bar]
$ hg log -r '("foo+bar")' $ hg log -r '("foo+bar")'
4:bbf52b87b370 Added tag foo-bar for changeset a50aae922707 [foo+bar] 4:bbf52b87b370 Added tag foo-bar for changeset a50aae922707 [foo+bar]
Test tag with numeric version number. Test tag with numeric version number.
$ hg tag '1.2' $ hg tag '1.2'

tests/test-revset.t

(date(this is a test) (date(this is a test)
^ here) ^ here)
[10] [10]
$ log 'date()' $ log 'date()'
hg: parse error: date requires a string hg: parse error: date requires a string
[10] [10]
$ log 'date' $ log 'date'
abort: unknown revision 'date' abort: unknown revision 'date'
[255] [10]
$ log 'date(' $ log 'date('
hg: parse error at 5: not a prefix: end hg: parse error at 5: not a prefix: end
(date( (date(
^ here) ^ here)
[10] [10]
$ log 'date("\xy")' $ log 'date("\xy")'
hg: parse error: invalid \x escape* (glob) hg: parse error: invalid \x escape* (glob)
[10] [10]
$ log 'date(tip)' $ log 'date(tip)'
hg: parse error: invalid date: 'tip' hg: parse error: invalid date: 'tip'
[10] [10]
$ log '0:date' $ log '0:date'
abort: unknown revision 'date' abort: unknown revision 'date'
[255] [10]
$ log '::"date"' $ log '::"date"'
abort: unknown revision 'date' abort: unknown revision 'date'
[255] [10]
$ hg book date -r 4 $ hg book date -r 4
$ log '0:date' $ log '0:date'
0 0
1 1
2 2
3 3
4 4
$ log '::date' $ log '::date'
2 2
$ log 'expectsize(2:0, 3)' $ log 'expectsize(2:0, 3)'
2 2
1 1
0 0
$ log 'expectsize(0:1, 1)' $ log 'expectsize(0:1, 1)'
abort: revset size mismatch. expected 1, got 2 abort: revset size mismatch. expected 1, got 2
[255] [10]
$ log 'expectsize(0:4, -1)' $ log 'expectsize(0:4, -1)'
hg: parse error: negative size hg: parse error: negative size
[10] [10]
$ log 'expectsize(0:2, 2:4)' $ log 'expectsize(0:2, 2:4)'
0 0
1 1
2 2
$ log 'expectsize(0:1, 3:5)' $ log 'expectsize(0:1, 3:5)'
abort: revset size mismatch. expected between 3 and 5, got 2 abort: revset size mismatch. expected between 3 and 5, got 2
[255] [10]
$ log 'expectsize(0:1, -1:2)' $ log 'expectsize(0:1, -1:2)'
hg: parse error: negative size hg: parse error: negative size
[10] [10]
$ log 'expectsize(0:1, 1:-2)' $ log 'expectsize(0:1, 1:-2)'
hg: parse error: negative size hg: parse error: negative size
[10] [10]
$ log 'expectsize(0:2, a:4)' $ log 'expectsize(0:2, a:4)'
hg: parse error: size range bounds must be integers hg: parse error: size range bounds must be integers
1 1
2 2
$ log 'expectsize(0:2, :)' $ log 'expectsize(0:2, :)'
0 0
1 1
2 2
$ log 'expectsize(0:2, 4:)' $ log 'expectsize(0:2, 4:)'
abort: revset size mismatch. expected between 4 and 11, got 3 abort: revset size mismatch. expected between 4 and 11, got 3
[255] [10]
$ log 'expectsize(0:2, :2)' $ log 'expectsize(0:2, :2)'
abort: revset size mismatch. expected between 0 and 2, got 3 abort: revset size mismatch. expected between 0 and 2, got 3
[255] [10]
Test getting list of node from file Test getting list of node from file
$ hg log -r '0:2' -T '{node}\n' > some.nodes $ hg log -r '0:2' -T '{node}\n' > some.nodes
$ hg log -r 'nodefromfile("some.nodes")' -T '{rev}\n' $ hg log -r 'nodefromfile("some.nodes")' -T '{rev}\n'
0 0
1 1
2 2
$ hg log -r 'nodefromfile("missing-file")' -T '{rev}\n' $ hg log -r 'nodefromfile("missing-file")' -T '{rev}\n'
abort: cannot open nodes file "missing-file": $ENOENT$ abort: cannot open nodes file "missing-file": $ENOENT$
[255] [255]
$ echo bad-node > bad.nodes $ echo bad-node > bad.nodes
$ hg log -r 'nodefromfile("bad.nodes")' -T '{rev}\n' $ hg log -r 'nodefromfile("bad.nodes")' -T '{rev}\n'
$ echo abcdefabcdefabcdeabcdeabcdeabcdeabcdeabc > missing.nodes $ echo abcdefabcdefabcdeabcdeabcdeabcdeabcdeabc > missing.nodes

tests/test-revset2.t

1 1
2 2
9 9
test unknown revision in `_list` test unknown revision in `_list`
$ log '0|unknown' $ log '0|unknown'
abort: unknown revision 'unknown' abort: unknown revision 'unknown'
[255] [10]
test integer range in `_list` test integer range in `_list`
$ log '-1|-10' $ log '-1|-10'
9 9
0 0
$ log '-10|-11' $ log '-10|-11'
abort: unknown revision '-11' abort: unknown revision '-11'
[255] [10]
$ log '9|10' $ log '9|10'
abort: unknown revision '10' abort: unknown revision '10'
[255] [10]
test '0000' != '0' in `_list` test '0000' != '0' in `_list`
$ log '0|0000' $ log '0|0000'
0 0
-1 -1
test ',' in `_list` test ',' in `_list`
test empty revset test empty revset
$ hg log 'none()' $ hg log 'none()'
we can use patterns when searching for tags we can use patterns when searching for tags
$ log 'tag("1..*")' $ log 'tag("1..*")'
abort: tag '1..*' does not exist abort: tag '1..*' does not exist
[255] [10]
$ log 'tag("re:1..*")' $ log 'tag("re:1..*")'
6 6
$ log 'tag("re:[0-9].[0-9]")' $ log 'tag("re:[0-9].[0-9]")'
6 6
$ log 'tag("literal:1.0")' $ log 'tag("literal:1.0")'
6 6
$ log 'tag("re:0..*")' $ log 'tag("re:0..*")'
$ log 'tag(unknown)' $ log 'tag(unknown)'
abort: tag 'unknown' does not exist abort: tag 'unknown' does not exist
[255] [10]
$ log 'tag("re:unknown")' $ log 'tag("re:unknown")'
$ log 'present(tag("unknown"))' $ log 'present(tag("unknown"))'
$ log 'present(tag("re:unknown"))' $ log 'present(tag("re:unknown"))'
$ log 'branch(unknown)' $ log 'branch(unknown)'
abort: unknown revision 'unknown' abort: unknown revision 'unknown'
[255] [10]
$ log 'branch("literal:unknown")' $ log 'branch("literal:unknown")'
abort: branch 'unknown' does not exist abort: branch 'unknown' does not exist
[255] [10]
$ log 'branch("re:unknown")' $ log 'branch("re:unknown")'
$ log 'present(branch("unknown"))' $ log 'present(branch("unknown"))'
$ log 'present(branch("re:unknown"))' $ log 'present(branch("re:unknown"))'
$ log 'user(bob)' $ log 'user(bob)'
2 2
$ log '4::8' $ log '4::8'
4 4
$ log '(2 or 3 or 1) and matching(1 or 2 or 3)' $ log '(2 or 3 or 1) and matching(1 or 2 or 3)'
2 2
3 3
1 1
$ log 'named("unknown")' $ log 'named("unknown")'
abort: namespace 'unknown' does not exist abort: namespace 'unknown' does not exist
[255] [10]
$ log 'named("re:unknown")' $ log 'named("re:unknown")'
$ log 'present(named("unknown"))' $ log 'present(named("unknown"))'
$ log 'present(named("re:unknown"))' $ log 'present(named("re:unknown"))'
$ log 'tag()' $ log 'tag()'
6 6
$ log 'named("tags")' $ log 'named("tags")'
6 6
8 8
$ log 'tip^foo' $ log 'tip^foo'
hg: parse error: ^ expects a number 0, 1, or 2 hg: parse error: ^ expects a number 0, 1, or 2
[10] [10]
$ log 'branchpoint()~-1' $ log 'branchpoint()~-1'
abort: revision in set has more than one child abort: revision in set has more than one child
[255] [10]
Bogus function gets suggestions Bogus function gets suggestions
$ log 'add()' $ log 'add()'
hg: parse error: unknown identifier: add hg: parse error: unknown identifier: add
(did you mean adds?) (did you mean adds?)
[10] [10]
$ log 'added()' $ log 'added()'
hg: parse error: unknown identifier: added hg: parse error: unknown identifier: added