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

equal deleted inserted replaced

-:346af7687c6f
+:89a2afe31e82
 return subset & ps
 @predicate(b'author(string)', safe=True, weight=10)
 def author(repo, subset, x):
-"""Alias for ``user(string)``.
+"""Alias for ``user(string)``."""
-"""
 # i18n: "author" is a keyword
 n = getstring(x, _(b"author requires a string"))
 kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
 return subset.filter(
 lambda x: matcher(repo[x].user()), condrepr=(b'<user %r>', n)
 return baseset(cs)
 @predicate(b'children(set)', safe=True)
 def children(repo, subset, x):
-"""Child changesets of changesets in set.
+"""Child changesets of changesets in set."""
-"""
 s = getset(repo, fullreposet(repo), x)
 cs = _children(repo, subset, s)
 return subset & cs
 @predicate(b'closed()', safe=True, weight=10)
 def closed(repo, subset, x):
-"""Changeset is closed.
+"""Changeset is closed."""
-"""
 # i18n: "closed" is a keyword
 getargs(x, 0, 0, _(b"closed takes no arguments"))
 return subset.filter(
 lambda r: repo[r].closesbranch(), condrepr=b'<branch closed>'
 )
 return subset & baseset(ancs)
 @predicate(b'commonancestors(set)', safe=True)
 def commonancestors(repo, subset, x):
-"""Changesets that are ancestors of every changeset in set.
+"""Changesets that are ancestors of every changeset in set."""
-"""
 startrevs = getset(repo, fullreposet(repo), x, order=anyorder)
 if not startrevs:
 return baseset()
 for r in startrevs:
 subset &= dagop.revancestors(repo, baseset([r]))
 )
 @predicate(b'date(interval)', safe=True, weight=10)
 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
 ds = getstring(x, _(b"date requires a string"))
 dm = dateutil.matchdate(ds)
 return subset.filter(
 lambda x: dm(repo[x].date()[0]), condrepr=(b'<date %r>', ds)
 return subset & baseset(data)
 @predicate(b'extinct()', safe=True)
 def extinct(repo, subset, x):
-"""Obsolete changesets with obsolete descendants only. (EXPERIMENTAL)
+"""Obsolete changesets with obsolete descendants only. (EXPERIMENTAL)"""
-"""
 # i18n: "extinct" is a keyword
 getargs(x, 0, 0, _(b"extinct takes no arguments"))
 extincts = obsmod.getrevs(repo, b'extinct')
 return subset & extincts
 return subset & s
 @predicate(b'first(set, [n])', safe=True, takeorder=True, weight=0)
 def first(repo, subset, x, order):
-"""An alias for limit().
+"""An alias for limit()."""
-"""
 return limit(repo, subset, x, order)
 def _follow(repo, subset, x, name, followfirst=False):
 args = getargsdict(x, name, b'file startrev')
 return subset & rs
 @predicate(b'all()', safe=True)
 def getall(repo, subset, x):
-"""All changesets, the same as ``0:tip``.
+"""All changesets, the same as ``0:tip``."""
-"""
 # i18n: "all" is a keyword
 getargs(x, 0, 0, _(b"all takes no arguments"))
 return subset & spanset(repo)  # drop "null" if any
 return _matchfiles(repo, subset, (b'string', b'p:' + pat))
 @predicate(b'head()', safe=True)
 def head(repo, subset, x):
-"""Changeset is a named branch head.
+"""Changeset is a named branch head."""
-"""
 # i18n: "head" is a keyword
 getargs(x, 0, 0, _(b"head takes no arguments"))
 hs = set()
 cl = repo.changelog
 for ls in repo.branchmap().iterheads():
 return subset & baseset(hs)
 @predicate(b'heads(set)', safe=True, takeorder=True)
 def heads(repo, subset, x, order):
-"""Members of set with no children in set.
+"""Members of set with no children in set."""
-"""
 # argument set should never define order
 if order == defineorder:
 order = followorder
 inputset = getset(repo, fullreposet(repo), x, order=order)
 wdirparents = None
 return subset & heads
 @predicate(b'hidden()', safe=True)
 def hidden(repo, subset, x):
-"""Hidden changesets.
+"""Hidden changesets."""
-"""
 # i18n: "hidden" is a keyword
 getargs(x, 0, 0, _(b"hidden takes no arguments"))
 hiddenrevs = repoview.filterrevs(repo, b'visible')
 return subset & hiddenrevs
 return subset.filter(matches, condrepr=(b'<keyword %r>', kw))
 @predicate(b'limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0)
 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, b'limit', b'set n offset')
 if b'set' not in args:
 # i18n: "limit" is a keyword
 raise error.ParseError(_(b"limit requires one to three arguments"))
 # i18n: "limit" is a keyword
 return ls & subset
 @predicate(b'last(set, [n])', safe=True, takeorder=True)
 def last(repo, subset, x, order):
-"""Last n members of set, defaulting to 1.
+"""Last n members of set, defaulting to 1."""
-"""
 # i18n: "last" is a keyword
 l = getargs(x, 1, 2, _(b"last requires one or two arguments"))
 lim = 1
 if len(l) == 2:
 # i18n: "last" is a keyword
 return ls & subset
 @predicate(b'max(set)', safe=True)
 def maxrev(repo, subset, x):
-"""Changeset with highest revision number in set.
+"""Changeset with highest revision number in set."""
-"""
 os = getset(repo, fullreposet(repo), x)
 try:
 m = os.max()
 if m in subset:
 return baseset([m], datarepr=(b'<max %r, %r>', subset, os))
 return baseset(datarepr=(b'<max %r, %r>', subset, os))
 @predicate(b'merge()', safe=True)
 def merge(repo, subset, x):
-"""Changeset is a merge changeset.
+"""Changeset is a merge changeset."""
-"""
 # i18n: "merge" is a keyword
 getargs(x, 0, 0, _(b"merge takes no arguments"))
 cl = repo.changelog
 nullrev = node.nullrev
 return subset.filter(ismerge, condrepr=b'<merge>')
 @predicate(b'branchpoint()', safe=True)
 def branchpoint(repo, subset, x):
-"""Changesets with more than one child.
+"""Changesets with more than one child."""
-"""
 # i18n: "branchpoint" is a keyword
 getargs(x, 0, 0, _(b"branchpoint takes no arguments"))
 cl = repo.changelog
 if not subset:
 return baseset()
 )
 @predicate(b'min(set)', safe=True)
 def minrev(repo, subset, x):
-"""Changeset with lowest revision number in set.
+"""Changeset with lowest revision number in set."""
-"""
 os = getset(repo, fullreposet(repo), x)
 try:
 m = os.min()
 if m in subset:
 return baseset([m], datarepr=(b'<min %r, %r>', subset, os))
 return subset & names
 @predicate(b'id(string)', safe=True)
 def node_(repo, subset, x):
-"""Revision non-ambiguously specified by the given hex string prefix.
+"""Revision non-ambiguously specified by the given hex string prefix."""
-"""
 # i18n: "id" is a keyword
 l = getargs(x, 1, 1, _(b"id requires one argument"))
 # i18n: "id" is a keyword
 n = getstring(l[0], _(b"id requires a string"))
 if len(n) == 40:
 return result & subset
 @predicate(b'none()', safe=True)
 def none(repo, subset, x):
-"""No changesets.
+"""No changesets."""
-"""
 # i18n: "none" is a keyword
 getargs(x, 0, 0, _(b"none takes no arguments"))
 return baseset()
 return subset & o
 @predicate(b'p1([set])', safe=True)
 def p1(repo, subset, x):
-"""First parent of changesets in set, or the working directory.
+"""First parent of changesets in set, or the working directory."""
-"""
 if x is None:
 p = repo[x].p1().rev()
 if p >= 0:
 return subset & baseset([p])
 return baseset()
 return subset & ps
 @predicate(b'p2([set])', safe=True)
 def p2(repo, subset, x):
-"""Second parent of changesets in set, or the working directory.
+"""Second parent of changesets in set, or the working directory."""
-"""
 if x is None:
 ps = repo[x].parents()
 try:
 p = ps[1].rev()
 if p >= 0:
 return subset.filter(matches, condrepr=(b'<matching%r %r>', fields, revs))
 @predicate(b'reverse(set)', safe=True, takeorder=True, weight=0)
 def reverse(repo, subset, x, order):
-"""Reverse order of set.
+"""Reverse order of set."""
-"""
 l = getset(repo, subset, x, order)
 if order == defineorder:
 l.reverse()
 return l
 @predicate(b'roots(set)', safe=True)
 def roots(repo, subset, x):
-"""Changesets in set with no parent changeset in set.
+"""Changesets in set with no parent changeset in set."""
-"""
 s = getset(repo, fullreposet(repo), x)
 parents = repo.changelog.parentrevs
 def filter(r):
 for p in parents(r):
 return tag(repo, subset, x)
 @predicate(b'orphan()', safe=True)
 def orphan(repo, subset, x):
-"""Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
+"""Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)"""
-"""
 # i18n: "orphan" is a keyword
 getargs(x, 0, 0, _(b"orphan takes no arguments"))
 orphan = obsmod.getrevs(repo, b'orphan')
 return subset & orphan
 @predicate(b'unstable()', safe=True)
 def unstable(repo, subset, x):
-"""Changesets with instabilities. (EXPERIMENTAL)
+"""Changesets with instabilities. (EXPERIMENTAL)"""
-"""
 # i18n: "unstable" is a keyword
 getargs(x, 0, 0, b'unstable takes no arguments')
 _unstable = set()
 _unstable.update(obsmod.getrevs(repo, b'orphan'))
 _unstable.update(obsmod.getrevs(repo, b'phasedivergent'))
 return mfunc
 def loadpredicate(ui, extname, registrarobj):
-"""Load revset predicates from specified registrarobj
+"""Load revset predicates from specified registrarobj"""
-"""
 for name, func in pycompat.iteritems(registrarobj._table):
 symbols[name] = func
 if func._safe:
 safesymbols.add(name)

changeset 45942	89a2afe31e82
parent 45750	c00595736595
child 46113	59fa3890d40a