mercurial/revset.py
256	I take it this dictionary was moved there because of the import direction?

mercurial/revset.py
256	Yes.

mercurial/registrar.py
175	contains() does not read file contents, but manifest contents.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	1666		Sep 7 2017, 12:16 PM	★	★
Diff 2	1882		Sep 18 2017, 7:46 PM	★	★
Diff 3	1883		Sep 18 2017, 7:48 PM	★	★
Diff 4	1895		Sep 19 2017, 1:31 PM	★	★
Diff 5	1896		Sep 19 2017, 1:45 PM	★	★
Diff 6	1919	rHGb0790bebfcf8fb81892adf7675561766aed056d4	Sep 1 2017, 10:42 PM	★	★

	Status	Author	Revision
	Closed	quark	D657 revset: move weight information to predicate
	Closed	quark	D656 revset: remove "small" argument from "_optimize"

Diff 1919

mercurial/registrar.py

	The first string argument is used also in online help.			The first string argument is used also in online help.

	Optional argument 'safe' indicates whether a predicate is safe for			Optional argument 'safe' indicates whether a predicate is safe for
	DoS attack (False by default).			DoS attack (False by default).

	Optional argument 'takeorder' indicates whether a predicate function			Optional argument 'takeorder' indicates whether a predicate function
	takes ordering policy as the last argument.			takes ordering policy as the last argument.

				Optional argument 'weight' indicates the estimated run-time cost, useful
				for static optimization, default is 1. Higher weight means more expensive.
				Usually, revsets that are fast and return only one revision has a weight of
				0.5 (ex. a symbol); revsets with O(changelog) complexity and read only the
				changelog have weight 10 (ex. author); revsets reading manifest deltas have
				weight 30 (ex. adds); revset reading manifest contents have weight 100
				(ex. contains). Note: those values are flexible. If the revset has a
				yujaUnsubmitted Not Done contains() does not read file contents, but manifest contents. yuja: contains() does not read file contents, but manifest contents.
				same big-O time complexity as 'contains', but with a smaller constant, it
				might have a weight of 90.

	'revsetpredicate' instance in example above can be used to			'revsetpredicate' instance in example above can be used to
	decorate multiple functions.			decorate multiple functions.

	Decorated functions are registered automatically at loading			Decorated functions are registered automatically at loading
	extension, if an instance named as 'revsetpredicate' is used for			extension, if an instance named as 'revsetpredicate' is used for
	decorating in extension.			decorating in extension.

	Otherwise, explicit 'revset.loadpredicate()' is needed.			Otherwise, explicit 'revset.loadpredicate()' is needed.
	"""			"""
	_getname = _funcregistrarbase._parsefuncdecl			_getname = _funcregistrarbase._parsefuncdecl
	_docformat = "``%s``\n %s"			_docformat = "``%s``\n %s"

	def _extrasetup(self, name, func, safe=False, takeorder=False):			def _extrasetup(self, name, func, safe=False, takeorder=False, weight=1):
	func._safe = safe			func._safe = safe
	func._takeorder = takeorder			func._takeorder = takeorder
				func._weight = weight

	class filesetpredicate(_funcregistrarbase):			class filesetpredicate(_funcregistrarbase):
	"""Decorator to register fileset predicate			"""Decorator to register fileset predicate

	Usage::			Usage::

	filesetpredicate = registrar.filesetpredicate()			filesetpredicate = registrar.filesetpredicate()

mercurial/revset.py

	# functions			# functions

	# symbols are callables like:			# symbols are callables like:
	# fn(repo, subset, x)			# fn(repo, subset, x)
	# with:			# with:
	# repo - current repository instance			# repo - current repository instance
	# subset - of revisions to be examined			# subset - of revisions to be examined
	# x - argument in tree form			# x - argument in tree form
	symbols = {}			symbols = revsetlang.symbols
				phillcoUnsubmitted Not Done I take it this dictionary was moved there because of the import direction? phillco: I take it this dictionary was moved there because of the import direction?
				quarkAuthorUnsubmitted Not Done Yes. quark: Yes.

	# symbols which can't be used for a DoS attack for any given input			# symbols which can't be used for a DoS attack for any given input
	# (e.g. those which accept regexes as plain strings shouldn't be included)			# (e.g. those which accept regexes as plain strings shouldn't be included)
	# functions that just return a lot of changesets (like all) don't count here			# functions that just return a lot of changesets (like all) don't count here
	safesymbols = set()			safesymbols = set()

	predicate = registrar.revsetpredicate()			predicate = registrar.revsetpredicate()

	@predicate('_destupdate')			@predicate('_destupdate')
	def _destupdate(repo, subset, x):			def _destupdate(repo, subset, x):
	# experimental revset for update destination			# experimental revset for update destination
	args = getargsdict(x, 'limit', 'clean')			args = getargsdict(x, 'limit', 'clean')
	return subset & baseset([destutil.destupdate(repo, **args)[0]])			return subset & baseset([destutil.destupdate(repo, **args)[0]])

	@predicate('_destmerge')			@predicate('_destmerge')
	def _destmerge(repo, subset, x):			def _destmerge(repo, subset, x):
	# experimental revset for merge destination			# experimental revset for merge destination
	sourceset = None			sourceset = None
	if x is not None:			if x is not None:
	sourceset = getset(repo, fullreposet(repo), x)			sourceset = getset(repo, fullreposet(repo), x)
	return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])			return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])

	@predicate('adds(pattern)', safe=True)			@predicate('adds(pattern)', safe=True, weight=30)
	def adds(repo, subset, x):			def adds(repo, subset, x):
	"""Changesets that add a file matching pattern.			"""Changesets that add a file matching pattern.

	The pattern without explicit kind like ``glob:`` is expected to be			The pattern without explicit kind like ``glob:`` is expected to be
	relative to the current directory and match against a file or a			relative to the current directory and match against a file or a
	directory.			directory.
	"""			"""
	# i18n: "adds" is a keyword			# i18n: "adds" is a keyword
	pat = getstring(x, _("adds requires a pattern"))			pat = getstring(x, _("adds requires a pattern"))
	return checkstatus(repo, subset, pat, 1)			return checkstatus(repo, subset, pat, 1)

	@predicate('ancestor(*changeset)', safe=True)			@predicate('ancestor(*changeset)', safe=True, weight=0.5)
	def ancestor(repo, subset, x):			def ancestor(repo, subset, x):
	"""A greatest common ancestor of the changesets.			"""A greatest common ancestor of the changesets.

	Accepts 0 or more changesets.			Accepts 0 or more changesets.
	Will return empty list when passed no args.			Will return empty list when passed no args.
	Greatest common ancestor of a single changeset is that changeset.			Greatest common ancestor of a single changeset is that changeset.
	"""			"""
	# i18n: "ancestor" is a keyword			# i18n: "ancestor" is a keyword
	for i in range(n):			for i in range(n):
	try:			try:
	r = cl.parentrevs(r)[0]			r = cl.parentrevs(r)[0]
	except error.WdirUnsupported:			except error.WdirUnsupported:
	r = repo[r].parents()[0].rev()			r = repo[r].parents()[0].rev()
	ps.add(r)			ps.add(r)
	return subset & ps			return subset & ps

	@predicate('author(string)', safe=True)			@predicate('author(string)', safe=True, weight=10)
	def author(repo, subset, x):			def author(repo, subset, x):
	"""Alias for ``user(string)``.			"""Alias for ``user(string)``.
	"""			"""
	# i18n: "author" is a keyword			# i18n: "author" is a keyword
	n = getstring(x, _("author requires a string"))			n = getstring(x, _("author requires a string"))
	kind, pattern, matcher = _substringmatcher(n, casesensitive=False)			kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
	return subset.filter(lambda x: matcher(repo[x].user()),			return subset.filter(lambda x: matcher(repo[x].user()),
	condrepr=('<user %r>', n))			condrepr=('<user %r>', n))
	" that match '%s'") % pattern)			" that match '%s'") % pattern)
	for bmrev in matchrevs:			for bmrev in matchrevs:
	bms.add(repo[bmrev].rev())			bms.add(repo[bmrev].rev())
	else:			else:
	bms = {repo[r].rev() for r in repo._bookmarks.values()}			bms = {repo[r].rev() for r in repo._bookmarks.values()}
	bms -= {node.nullrev}			bms -= {node.nullrev}
	return subset & bms			return subset & bms

	@predicate('branch(string or set)', safe=True)			@predicate('branch(string or set)', safe=True, weight=10)
	def branch(repo, subset, x):			def branch(repo, subset, x):
	"""			"""
	All changesets belonging to the given branch or the branches of the given			All changesets belonging to the given branch or the branches of the given
	changesets.			changesets.

	Pattern matching is supported for `string`. See			Pattern matching is supported for `string`. See
	:hg:`help revisions.patterns`.			:hg:`help revisions.patterns`.
	"""			"""
	@predicate('children(set)', safe=True)			@predicate('children(set)', safe=True)
	def children(repo, subset, x):			def children(repo, subset, x):
	"""Child changesets of changesets in set.			"""Child changesets of changesets in set.
	"""			"""
	s = getset(repo, fullreposet(repo), x)			s = getset(repo, fullreposet(repo), x)
	cs = _children(repo, subset, s)			cs = _children(repo, subset, s)
	return subset & cs			return subset & cs

	@predicate('closed()', safe=True)			@predicate('closed()', safe=True, weight=10)
	def closed(repo, subset, x):			def closed(repo, subset, x):
	"""Changeset is closed.			"""Changeset is closed.
	"""			"""
	# i18n: "closed" is a keyword			# i18n: "closed" is a keyword
	getargs(x, 0, 0, _("closed takes no arguments"))			getargs(x, 0, 0, _("closed takes no arguments"))
	return subset.filter(lambda r: repo[r].closesbranch(),			return subset.filter(lambda r: repo[r].closesbranch(),
	condrepr='<branch closed>')			condrepr='<branch closed>')

	@predicate('contains(pattern)')			@predicate('contains(pattern)', weight=100)
	def contains(repo, subset, x):			def contains(repo, subset, x):
	"""The revision's manifest contains a file matching pattern (but might not			"""The revision's manifest contains a file matching pattern (but might not
	modify it). See :hg:`help patterns` for information about file patterns.			modify it). See :hg:`help patterns` for information about file patterns.

	The pattern without explicit kind like ``glob:`` is expected to be			The pattern without explicit kind like ``glob:`` is expected to be
	relative to the current directory and match against a file exactly			relative to the current directory and match against a file exactly
	for efficiency.			for efficiency.
	"""			"""

	def _matchvalue(r):			def _matchvalue(r):
	source = repo[r].extra().get('convert_revision', None)			source = repo[r].extra().get('convert_revision', None)
	return source is not None and (rev is None or source.startswith(rev))			return source is not None and (rev is None or source.startswith(rev))

	return subset.filter(lambda r: _matchvalue(r),			return subset.filter(lambda r: _matchvalue(r),
	condrepr=('<converted %r>', rev))			condrepr=('<converted %r>', rev))

	@predicate('date(interval)', safe=True)			@predicate('date(interval)', safe=True, weight=10)
	def date(repo, subset, x):			def date(repo, subset, x):
	"""Changesets within the interval, see :hg:`help dates`.			"""Changesets within the interval, see :hg:`help dates`.
	"""			"""
	# i18n: "date" is a keyword			# i18n: "date" is a keyword
	ds = getstring(x, _("date requires a string"))			ds = getstring(x, _("date requires a string"))
	dm = util.matchdate(ds)			dm = util.matchdate(ds)
	return subset.filter(lambda x: dm(repo[x].date()[0]),			return subset.filter(lambda x: dm(repo[x].date()[0]),
	condrepr=('<date %r>', ds))			condrepr=('<date %r>', ds))

	@predicate('desc(string)', safe=True)			@predicate('desc(string)', safe=True, weight=10)
	def desc(repo, subset, x):			def desc(repo, subset, x):
	"""Search commit message for string. The match is case-insensitive.			"""Search commit message for string. The match is case-insensitive.

	Pattern matching is supported for `string`. See			Pattern matching is supported for `string`. See
	:hg:`help revisions.patterns`.			:hg:`help revisions.patterns`.
	"""			"""
	# i18n: "desc" is a keyword			# i18n: "desc" is a keyword
	ds = getstring(x, _("desc requires a string"))			ds = getstring(x, _("desc requires a string"))
	startdepth=startdepth, stopdepth=stopdepth)			startdepth=startdepth, stopdepth=stopdepth)

	@predicate('_firstdescendants', safe=True)			@predicate('_firstdescendants', safe=True)
	def _firstdescendants(repo, subset, x):			def _firstdescendants(repo, subset, x):
	# ``_firstdescendants(set)``			# ``_firstdescendants(set)``
	# Like ``descendants(set)`` but follows only the first parents.			# Like ``descendants(set)`` but follows only the first parents.
	return _descendants(repo, subset, x, followfirst=True)			return _descendants(repo, subset, x, followfirst=True)

	@predicate('destination([set])', safe=True)			@predicate('destination([set])', safe=True, weight=10)
	def destination(repo, subset, x):			def destination(repo, subset, x):
	"""Changesets that were created by a graft, transplant or rebase operation,			"""Changesets that were created by a graft, transplant or rebase operation,
	with the given revisions specified as the source. Omitting the optional set			with the given revisions specified as the source. Omitting the optional set
	is the same as passing all().			is the same as passing all().
	"""			"""
	if x is not None:			if x is not None:
	sources = getset(repo, fullreposet(repo), x)			sources = getset(repo, fullreposet(repo), x)
	else:			else:
	else:			else:
	known[n] = r			known[n] = r
	except error.ManifestLookupError:			except error.ManifestLookupError:
	# deletion in changelog			# deletion in changelog
	continue			continue

	return subset & s			return subset & s

	@predicate('first(set, [n])', safe=True, takeorder=True)			@predicate('first(set, [n])', safe=True, takeorder=True, weight=0)
	def first(repo, subset, x, order):			def first(repo, subset, x, order):
	"""An alias for limit().			"""An alias for limit().
	"""			"""
	return limit(repo, subset, x, order)			return limit(repo, subset, x, order)

	def _follow(repo, subset, x, name, followfirst=False):			def _follow(repo, subset, x, name, followfirst=False):
	l = getargs(x, 0, 2, _("%s takes no arguments or a pattern "			l = getargs(x, 0, 2, _("%s takes no arguments or a pattern "
	"and an optional revset") % name)			"and an optional revset") % name)
	@predicate('all()', safe=True)			@predicate('all()', safe=True)
	def getall(repo, subset, x):			def getall(repo, subset, x):
	"""All changesets, the same as ``0:tip``.			"""All changesets, the same as ``0:tip``.
	"""			"""
	# i18n: "all" is a keyword			# i18n: "all" is a keyword
	getargs(x, 0, 0, _("all takes no arguments"))			getargs(x, 0, 0, _("all takes no arguments"))
	return subset & spanset(repo) # drop "null" if any			return subset & spanset(repo) # drop "null" if any

	@predicate('grep(regex)')			@predicate('grep(regex)', weight=10)
	def grep(repo, subset, x):			def grep(repo, subset, x):
	"""Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``			"""Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
	to ensure special escape characters are handled correctly. Unlike			to ensure special escape characters are handled correctly. Unlike
	``keyword(string)``, the match is case-sensitive.			``keyword(string)``, the match is case-sensitive.
	"""			"""
	try:			try:
	# i18n: "grep" is a keyword			# i18n: "grep" is a keyword
	gr = re.compile(getstring(x, _("grep requires a string")))			gr = re.compile(getstring(x, _("grep requires a string")))
	return True			return True
	return False			return False

	return subset.filter(matches,			return subset.filter(matches,
	condrepr=('<matchfiles patterns=%r, include=%r '			condrepr=('<matchfiles patterns=%r, include=%r '
	'exclude=%r, default=%r, rev=%r>',			'exclude=%r, default=%r, rev=%r>',
	pats, inc, exc, default, rev))			pats, inc, exc, default, rev))

	@predicate('file(pattern)', safe=True)			@predicate('file(pattern)', safe=True, weight=10)
	def hasfile(repo, subset, x):			def hasfile(repo, subset, x):
	"""Changesets affecting files matched by pattern.			"""Changesets affecting files matched by pattern.

	For a faster but less accurate result, consider using ``filelog()``			For a faster but less accurate result, consider using ``filelog()``
	instead.			instead.

	This predicate uses ``glob:`` as the default kind of pattern.			This predicate uses ``glob:`` as the default kind of pattern.
	"""			"""
	def hidden(repo, subset, x):			def hidden(repo, subset, x):
	"""Hidden changesets.			"""Hidden changesets.
	"""			"""
	# i18n: "hidden" is a keyword			# i18n: "hidden" is a keyword
	getargs(x, 0, 0, _("hidden takes no arguments"))			getargs(x, 0, 0, _("hidden takes no arguments"))
	hiddenrevs = repoview.filterrevs(repo, 'visible')			hiddenrevs = repoview.filterrevs(repo, 'visible')
	return subset & hiddenrevs			return subset & hiddenrevs

	@predicate('keyword(string)', safe=True)			@predicate('keyword(string)', safe=True, weight=10)
	def keyword(repo, subset, x):			def keyword(repo, subset, x):
	"""Search commit message, user name, and names of changed files for			"""Search commit message, user name, and names of changed files for
	string. The match is case-insensitive.			string. The match is case-insensitive.

	For a regular expression or case sensitive search of these fields, use			For a regular expression or case sensitive search of these fields, use
	``grep(regex)``.			``grep(regex)``.
	"""			"""
	# i18n: "keyword" is a keyword			# i18n: "keyword" is a keyword
	kw = encoding.lower(getstring(x, _("keyword requires a string")))			kw = encoding.lower(getstring(x, _("keyword requires a string")))

	def matches(r):			def matches(r):
	c = repo[r]			c = repo[r]
	return any(kw in encoding.lower(t)			return any(kw in encoding.lower(t)
	for t in c.files() + [c.user(), c.description()])			for t in c.files() + [c.user(), c.description()])

	return subset.filter(matches, condrepr=('<keyword %r>', kw))			return subset.filter(matches, condrepr=('<keyword %r>', kw))

	@predicate('limit(set[, n[, offset]])', safe=True, takeorder=True)			@predicate('limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0)
	def limit(repo, subset, x, order):			def limit(repo, subset, x, order):
	"""First n members of set, defaulting to 1, starting from offset.			"""First n members of set, defaulting to 1, starting from offset.
	"""			"""
	args = getargsdict(x, 'limit', 'set n offset')			args = getargsdict(x, 'limit', 'set n offset')
	if 'set' not in args:			if 'set' not in args:
	# i18n: "limit" is a keyword			# i18n: "limit" is a keyword
	raise error.ParseError(_("limit requires one to three arguments"))			raise error.ParseError(_("limit requires one to three arguments"))
	# i18n: "limit" is a keyword			# i18n: "limit" is a keyword
	if m in subset:			if m in subset:
	return baseset([m], datarepr=('<min %r, %r>', subset, os))			return baseset([m], datarepr=('<min %r, %r>', subset, os))
	except ValueError:			except ValueError:
	# os.min() throws a ValueError when the collection is empty.			# os.min() throws a ValueError when the collection is empty.
	# Same as python's min().			# Same as python's min().
	pass			pass
	return baseset(datarepr=('<min %r, %r>', subset, os))			return baseset(datarepr=('<min %r, %r>', subset, os))

	@predicate('modifies(pattern)', safe=True)			@predicate('modifies(pattern)', safe=True, weight=30)
	def modifies(repo, subset, x):			def modifies(repo, subset, x):
	"""Changesets modifying files matched by pattern.			"""Changesets modifying files matched by pattern.

	The pattern without explicit kind like ``glob:`` is expected to be			The pattern without explicit kind like ``glob:`` is expected to be
	relative to the current directory and match against a file or a			relative to the current directory and match against a file or a
	directory.			directory.
	"""			"""
	# i18n: "modifies" is a keyword			# i18n: "modifies" is a keyword
	src = prev			src = prev

	o = {_firstsrc(r) for r in dests}			o = {_firstsrc(r) for r in dests}
	o -= {None}			o -= {None}
	# XXX we should turn this into a baseset instead of a set, smartset may do			# XXX we should turn this into a baseset instead of a set, smartset may do
	# some optimizations from the fact this is a baseset.			# some optimizations from the fact this is a baseset.
	return subset & o			return subset & o

	@predicate('outgoing([path])', safe=False)			@predicate('outgoing([path])', safe=False, weight=10)
	def outgoing(repo, subset, x):			def outgoing(repo, subset, x):
	"""Changesets not found in the specified destination repository, or the			"""Changesets not found in the specified destination repository, or the
	default push location.			default push location.
	"""			"""
	# Avoid cycles.			# Avoid cycles.
	from . import (			from . import (
	discovery,			discovery,
	hg,			hg,
	other = hg.peer(repo, {}, dest)			other = hg.peer(repo, {}, dest)
	n = other.lookup(q)			n = other.lookup(q)
	if n in repo:			if n in repo:
	r = repo[n].rev()			r = repo[n].rev()
	if r in subset:			if r in subset:
	return baseset([r])			return baseset([r])
	return baseset()			return baseset()

	@predicate('removes(pattern)', safe=True)			@predicate('removes(pattern)', safe=True, weight=30)
	def removes(repo, subset, x):			def removes(repo, subset, x):
	"""Changesets which remove files matching pattern.			"""Changesets which remove files matching pattern.

	The pattern without explicit kind like ``glob:`` is expected to be			The pattern without explicit kind like ``glob:`` is expected to be
	relative to the current directory and match against a file or a			relative to the current directory and match against a file or a
	directory.			directory.
	"""			"""
	# i18n: "removes" is a keyword			# i18n: "removes" is a keyword
	if target[n] != f(x):			if target[n] != f(x):
	match = False			match = False
	if match:			if match:
	return True			return True
	return False			return False

	return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))			return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))

	@predicate('reverse(set)', safe=True, takeorder=True)			@predicate('reverse(set)', safe=True, takeorder=True, weight=0)
	def reverse(repo, subset, x, order):			def reverse(repo, subset, x, order):
	"""Reverse order of set.			"""Reverse order of set.
	"""			"""
	l = getset(repo, subset, x, order)			l = getset(repo, subset, x, order)
	if order == defineorder:			if order == defineorder:
	l.reverse()			l.reverse()
	return l			return l

	opts['topo.firstbranch'] = args['topo.firstbranch']			opts['topo.firstbranch'] = args['topo.firstbranch']
	else:			else:
	# i18n: "topo" and "topo.firstbranch" are keywords			# i18n: "topo" and "topo.firstbranch" are keywords
	raise error.ParseError(_('topo.firstbranch can only be used '			raise error.ParseError(_('topo.firstbranch can only be used '
	'when using the topo sort key'))			'when using the topo sort key'))

	return args['set'], keyflags, opts			return args['set'], keyflags, opts

	@predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True)			@predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True,
				weight=10)
	def sort(repo, subset, x, order):			def sort(repo, subset, x, order):
	"""Sort set by keys. The default sort order is ascending, specify a key			"""Sort set by keys. The default sort order is ascending, specify a key
	as ``-key`` to sort in descending order.			as ``-key`` to sort in descending order.

	The keys can be:			The keys can be:

	- ``rev`` for the revision number,			- ``rev`` for the revision number,
	- ``branch`` for the branch name,			- ``branch`` for the branch name,
	"""Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)			"""Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
	"""			"""
	# i18n: "orphan" is a keyword			# i18n: "orphan" is a keyword
	getargs(x, 0, 0, _("orphan takes no arguments"))			getargs(x, 0, 0, _("orphan takes no arguments"))
	orphan = obsmod.getrevs(repo, 'orphan')			orphan = obsmod.getrevs(repo, 'orphan')
	return subset & orphan			return subset & orphan


	@predicate('user(string)', safe=True)			@predicate('user(string)', safe=True, weight=10)
	def user(repo, subset, x):			def user(repo, subset, x):
	"""User name contains string. The match is case-insensitive.			"""User name contains string. The match is case-insensitive.

	Pattern matching is supported for `string`. See			Pattern matching is supported for `string`. See
	:hg:`help revisions.patterns`.			:hg:`help revisions.patterns`.
	"""			"""
	return author(repo, subset, x)			return author(repo, subset, x)

	@predicate('wdir()', safe=True)			@predicate('wdir()', safe=True, weight=0)
	def wdir(repo, subset, x):			def wdir(repo, subset, x):
	"""Working directory. (EXPERIMENTAL)"""			"""Working directory. (EXPERIMENTAL)"""
	# i18n: "wdir" is a keyword			# i18n: "wdir" is a keyword
	getargs(x, 0, 0, _("wdir takes no arguments"))			getargs(x, 0, 0, _("wdir takes no arguments"))
	if node.wdirrev in subset or isinstance(subset, fullreposet):			if node.wdirrev in subset or isinstance(subset, fullreposet):
	return baseset([node.wdirrev])			return baseset([node.wdirrev])
	return baseset()			return baseset()

	s = getstring(x, "internal error")			s = getstring(x, "internal error")
	if not s:			if not s:
	return baseset()			return baseset()
	ls = [int(r) for r in s.split('\0')]			ls = [int(r) for r in s.split('\0')]
	s = subset			s = subset
	return baseset([r for r in ls if r in s])			return baseset([r for r in ls if r in s])

	# for internal use			# for internal use
	@predicate('_intlist', safe=True, takeorder=True)			@predicate('_intlist', safe=True, takeorder=True, weight=0)
	def _intlist(repo, subset, x, order):			def _intlist(repo, subset, x, order):
	if order == followorder:			if order == followorder:
	# slow path to take the subset order			# slow path to take the subset order
	return subset & _orderedintlist(repo, fullreposet(repo), x)			return subset & _orderedintlist(repo, fullreposet(repo), x)
	else:			else:
	return _orderedintlist(repo, subset, x)			return _orderedintlist(repo, subset, x)

	def _orderedhexlist(repo, subset, x):			def _orderedhexlist(repo, subset, x):

mercurial/revsetlang.py

	"]": (0, None, None, None, None),			"]": (0, None, None, None, None),
	"symbol": (0, "symbol", None, None, None),			"symbol": (0, "symbol", None, None, None),
	"string": (0, "string", None, None, None),			"string": (0, "string", None, None, None),
	"end": (0, None, None, None, None),			"end": (0, None, None, None, None),
	}			}

	keywords = {'and', 'or', 'not'}			keywords = {'and', 'or', 'not'}

				symbols = {}

	_quoteletters = {'"', "'"}			_quoteletters = {'"', "'"}
	_simpleopletters = set(pycompat.iterbytestr("()[]#:=,-\|&+!~^%"))			_simpleopletters = set(pycompat.iterbytestr("()[]#:=,-\|&+!~^%"))

	# default set of valid characters for the initial letter of symbols			# default set of valid characters for the initial letter of symbols
	_syminitletters = set(pycompat.iterbytestr(			_syminitletters = set(pycompat.iterbytestr(
	string.ascii_letters.encode('ascii') +			string.ascii_letters.encode('ascii') +
	string.digits.encode('ascii') +			string.digits.encode('ascii') +
	'._@')) \| set(map(pycompat.bytechr, xrange(128, 256)))			'._@')) \| set(map(pycompat.bytechr, xrange(128, 256)))
	ws, ts = zip(*(_optimize(y) for y in x[1:]))			ws, ts = zip(*(_optimize(y) for y in x[1:]))
	return sum(ws), (op,) + ts			return sum(ws), (op,) + ts
	elif op == 'keyvalue':			elif op == 'keyvalue':
	w, t = _optimize(x[2])			w, t = _optimize(x[2])
	return w, (op, x[1], t)			return w, (op, x[1], t)
	elif op == 'func':			elif op == 'func':
	f = getsymbol(x[1])			f = getsymbol(x[1])
	wa, ta = _optimize(x[2])			wa, ta = _optimize(x[2])
	if f in ('author', 'branch', 'closed', 'date', 'desc', 'file', 'grep',			w = getattr(symbols.get(f), '_weight', 1)
	'keyword', 'outgoing', 'user', 'destination'):
	w = 10 # slow
	elif f in ('modifies', 'adds', 'removes'):
	w = 30 # slower
	elif f == "contains":
	w = 100 # very slow
	elif f == "ancestor":
	w = 0.5
	elif f in ('reverse', 'limit', 'first', 'wdir', '_intlist'):
	w = 0
	elif f == "sort":
	w = 10 # assume most sorts look at changelog
	else:
	w = 1
	return w + wa, (op, x[1], ta)			return w + wa, (op, x[1], ta)
	raise ValueError('invalid operator %r' % op)			raise ValueError('invalid operator %r' % op)

	def optimize(tree):			def optimize(tree):
	"""Optimize evaluatable tree			"""Optimize evaluatable tree

	All pseudo operations should be transformed beforehand.			All pseudo operations should be transformed beforehand.
	"""			"""

			Path	Packages
M			mercurial/registrar.py (13 lines)
M			mercurial/revset.py (47 lines)
M			mercurial/revsetlang.py (18 lines)

This is an archive of the discontinued Mercurial Phabricator instance.

revset: move weight information to predicate
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 1919

mercurial/registrar.py

mercurial/revset.py

mercurial/revsetlang.py

This is an archive of the discontinued Mercurial Phabricator instance.

revset: move weight information to predicateClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 1919

mercurial/registrar.py

mercurial/revset.py

mercurial/revsetlang.py

revset: move weight information to predicate
ClosedPublic

Revision Contents
Changeset List