mercurial-scm/hg-stable: mercurial/revset.py comparison

comparison mercurial/revset.py @ 28424:534f968d33e5

revset: add inspection data to all filter() calls This is useful for debugging revset construction.

author	Yuya Nishihara <yuya@tcha.org>
date	Sat, 13 Feb 2016 20:05:57 +0900
parents	0d79d91ba7e3
children	02d7faaf455c

comparison

equal deleted inserted replaced

-:0d79d91ba7e3
+:534f968d33e5
 """Alias for ``user(string)``.
 """
 # i18n: "author" is a keyword
 n = encoding.lower(getstring(x, _("author requires a string")))
 kind, pattern, matcher = _substringmatcher(n)
-return subset.filter(lambda x: matcher(encoding.lower(repo[x].user())))
+return subset.filter(lambda x: matcher(encoding.lower(repo[x].user())),
+condrepr=('<user %r>', n))
 @predicate('bisect(string)', safe=True)
 def bisect(repo, subset, x):
 """Changesets marked in the specified bisect status:
 kind, pattern, matcher = util.stringmatcher(b)
 if kind == 'literal':
 # note: falls through to the revspec case if no branch with
 # this name exists and pattern kind is not specified explicitly
 if pattern in repo.branchmap():
-return subset.filter(lambda r: matcher(getbi(r)[0]))
+return subset.filter(lambda r: matcher(getbi(r)[0]),
+condrepr=('<branch %r>', b))
 if b.startswith('literal:'):
 raise error.RepoLookupError(_("branch '%s' does not exist")
 % pattern)
 else:
-return subset.filter(lambda r: matcher(getbi(r)[0]))
+return subset.filter(lambda r: matcher(getbi(r)[0]),
+condrepr=('<branch %r>', b))
 s = getset(repo, fullreposet(repo), x)
 b = set()
 for r in s:
 b.add(getbi(r)[0])
 c = s.__contains__
-return subset.filter(lambda r: c(r) or getbi(r)[0] in b)
+return subset.filter(lambda r: c(r) or getbi(r)[0] in b,
+condrepr=lambda: '<branch %r>' % sorted(b))
 @predicate('bumped()', safe=True)
 def bumped(repo, subset, x):
 """Mutable changesets marked as successors of public changesets.
 else:
 for f in files:
 if m(f):
 return True
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat))
 def _children(repo, narrow, parentset):
 if not parentset:
 return baseset()
 cs = set()
 def closed(repo, subset, x):
 """Changeset is closed.
 """
 # i18n: "closed" is a keyword
 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>')
 @predicate('contains(pattern)')
 def contains(repo, subset, x):
 """The revision's manifest contains a file matching pattern (but might not
 modify it). See :hg:`help patterns` for information about file patterns.
 for f in c.manifest():
 if m(f):
 return True
 return False
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<contains %r>', pat))
 @predicate('converted([id])', safe=True)
 def converted(repo, subset, x):
 """Changesets converted from the given identifier in the old repository if
 present, or all converted changesets if no identifier is specified.
 def _matchvalue(r):
 source = repo[r].extra().get('convert_revision', None)
 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))
 @predicate('date(interval)', safe=True)
 def date(repo, subset, x):
 """Changesets within the interval, see :hg:`help dates`.
 """
 # i18n: "date" is a keyword
 ds = getstring(x, _("date requires a string"))
 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))
 @predicate('desc(string)', safe=True)
 def desc(repo, subset, x):
 """Search commit message for string. The match is case-insensitive.
 """
 def matches(x):
 c = repo[x]
 return ds in encoding.lower(c.description())
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<desc %r>', ds))
 def _descendants(repo, subset, x, followfirst=False):
 roots = getset(repo, fullreposet(repo), x)
 if not roots:
 return baseset()
 break
 r = src
 src = _getrevsource(repo, r)
-return subset.filter(dests.__contains__)
+return subset.filter(dests.__contains__,
+condrepr=lambda: '<destination %r>' % sorted(dests))
 @predicate('divergent()', safe=True)
 def divergent(repo, subset, x):
 """
 Final successors of changesets with an alternative set of final successors.
 def _matchvalue(r):
 extra = repo[r].extra()
 return label in extra and (value is None or matcher(extra[label]))
-return subset.filter(lambda r: _matchvalue(r))
+return subset.filter(lambda r: _matchvalue(r),
+condrepr=('<extra[%r] %r>', label, value))
 @predicate('filelog(pattern)', safe=True)
 def filelog(repo, subset, x):
 """Changesets connected to the specified filelog.
 for e in c.files() + [c.user(), c.description()]:
 if gr.search(e):
 return True
 return False
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<grep %r>', gr.pattern))
 @predicate('_matchfiles', safe=True)
 def _matchfiles(repo, subset, x):
 # _matchfiles takes a revset list of prefixed arguments:
 #
 for f in files:
 if m(f):
 return True
 return False
-return subset.filter(matches)
+return subset.filter(matches,
+condrepr=('<matchfiles patterns=%r, include=%r '
+'exclude=%r, default=%r, rev=%r>',
+pats, inc, exc, default, rev))
 @predicate('file(pattern)', safe=True)
 def hasfile(repo, subset, x):
 """Changesets affecting files matched by pattern.
 def matches(r):
 c = repo[r]
 return any(kw in encoding.lower(t)
 for t in c.files() + [c.user(), c.description()])
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<keyword %r>', kw))
 @predicate('limit(set[, n[, offset]])', safe=True)
 def limit(repo, subset, x):
 """First n members of set, defaulting to 1, starting from offset.
 """
 """Changeset is a merge changeset.
 """
 # i18n: "merge" is a keyword
 getargs(x, 0, 0, _("merge takes no arguments"))
 cl = repo.changelog
-return subset.filter(lambda r: cl.parentrevs(r)[1] != -1)
+return subset.filter(lambda r: cl.parentrevs(r)[1] != -1,
+condrepr='<merge>')
 @predicate('branchpoint()', safe=True)
 def branchpoint(repo, subset, x):
 """Changesets with more than one child.
 """
 parentscount = [0]*(len(repo) - baserev)
 for r in cl.revs(start=baserev + 1):
 for p in cl.parentrevs(r):
 if p >= baserev:
 parentscount[p - baserev] += 1
-return subset.filter(lambda r: parentscount[r - baserev] > 1)
+return subset.filter(lambda r: parentscount[r - baserev] > 1,
+condrepr='<branchpoint>')
 @predicate('min(set)', safe=True)
 def minrev(repo, subset, x):
 """Changeset with lowest revision number in set.
 """
 s.sort() # set are non ordered, so we enforce ascending
 return subset & s
 else:
 phase = repo._phasecache.phase
 condition = lambda r: phase(repo, r) == target
-return subset.filter(condition, cache=False)
+return subset.filter(condition, condrepr=('<phase %r>', target),
+cache=False)
 @predicate('draft()', safe=True)
 def draft(repo, subset, x):
 """Changeset in draft phase."""
 # i18n: "draft" is a keyword
 return subset & s
 else:
 phase = repo._phasecache.phase
 target = phases.public
 condition = lambda r: phase(repo, r) != target
-return subset.filter(condition, cache=False)
+return subset.filter(condition, condrepr=('<phase %r>', target),
+cache=False)
 @predicate('public()', safe=True)
 def public(repo, subset, x):
 """Changeset in public phase."""
 # i18n: "public" is a keyword
 getargs(x, 0, 0, _("public takes no arguments"))
 phase = repo._phasecache.phase
 target = phases.public
 condition = lambda r: phase(repo, r) == target
-return subset.filter(condition, cache=False)
+return subset.filter(condition, condrepr=('<phase %r>', target),
+cache=False)
 @predicate('remote([id [,path]])', safe=True)
 def remote(repo, subset, x):
 """Local revision that corresponds to the given identifier in a
 remote repository, if present. Here, the '.' identifier is a
 match = False
 if match:
 return True
 return False
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
 @predicate('reverse(set)', safe=True)
 def reverse(repo, subset, x):
 """Reverse order of set.
 """
 def filter(r):
 for p in parents(r):
 if 0 <= p and p in s:
 return False
 return True
-return subset & s.filter(filter)
+return subset & s.filter(filter, condrepr='<roots>')
 @predicate('sort(set[, [-]key...])', safe=True)
 def sort(repo, subset, x):
 """Sort set by keys. The default sort order is ascending, specify a key
 as ``-key`` to sort in descending order.
 if s.removed:
 return any(submatches(c.p1().substate.keys()))
 return False
-return subset.filter(matches)
+return subset.filter(matches, condrepr=('<subrepo %r>', pat))
 def _substringmatcher(pattern):
 kind, pattern, matcher = util.stringmatcher(pattern)
 if kind == 'literal':
 matcher = lambda s: pattern in s

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revset.py @ 28424:534f968d33e5