Mercurial: comparison mercurial/revset.py

equal deleted inserted replaced

-:0edc0aa7432d
+:165079e564f0
 raise error.ParseError(_("not a function: %s") % a[1])
 # functions
 def node(repo, subset, x):
+"""``id(string)``
+Revision non-ambiguously specified by the given hex string prefix
+"""
 # i18n: "id" is a keyword
 l = getargs(x, 1, 1, _("id requires one argument"))
 # i18n: "id" is a keyword
 n = getstring(l[0], _("id requires a string"))
 if len(n) == 40:
 else:
 rn = repo.changelog.rev(repo.changelog._partialmatch(n))
 return [r for r in subset if r == rn]
 def rev(repo, subset, x):
+"""``rev(number)``
+Revision with the given numeric identifier.
+"""
 # i18n: "rev" is a keyword
 l = getargs(x, 1, 1, _("rev requires one argument"))
 try:
 # i18n: "rev" is a keyword
 l = int(getstring(l[0], _("rev requires a number")))
 # i18n: "rev" is a keyword
 raise error.ParseError(_("rev expects a number"))
 return [r for r in subset if r == l]
 def p1(repo, subset, x):
+"""``p1(set)``
+First parent of changesets in set.
+"""
 ps = set()
 cl = repo.changelog
 for r in getset(repo, range(len(repo)), x):
 ps.add(cl.parentrevs(r)[0])
 return [r for r in subset if r in ps]
 def p2(repo, subset, x):
+"""``p2(set)``
+Second parent of changesets in set.
+"""
 ps = set()
 cl = repo.changelog
 for r in getset(repo, range(len(repo)), x):
 ps.add(cl.parentrevs(r)[1])
 return [r for r in subset if r in ps]
 def parents(repo, subset, x):
+"""``parents(set)``
+The set of all parents for all changesets in set.
+"""
 ps = set()
 cl = repo.changelog
 for r in getset(repo, range(len(repo)), x):
 ps.update(cl.parentrevs(r))
 return [r for r in subset if r in ps]
 def maxrev(repo, subset, x):
+"""``max(set)``
+Changeset with highest revision number in set.
+"""
 s = getset(repo, subset, x)
 if s:
 m = max(s)
 if m in subset:
 return [m]
 return []
 def minrev(repo, subset, x):
+"""``min(set)``
+Changeset with lowest revision number in set.
+"""
 s = getset(repo, subset, x)
 if s:
 m = min(s)
 if m in subset:
 return [m]
 return []
 def limit(repo, subset, x):
+"""``limit(set, n)``
+First n members of set.
+"""
 # i18n: "limit" is a keyword
 l = getargs(x, 2, 2, _("limit requires two arguments"))
 try:
 # i18n: "limit" is a keyword
 lim = int(getstring(l[1], _("limit requires a number")))
 # i18n: "limit" is a keyword
 raise error.ParseError(_("limit expects a number"))
 return getset(repo, subset, l[0])[:lim]
 def children(repo, subset, x):
+"""``children(set)``
+Child changesets of changesets in set.
+"""
 cs = set()
 cl = repo.changelog
 s = set(getset(repo, range(len(repo)), x))
 for r in xrange(0, len(repo)):
 for p in cl.parentrevs(r):
 if p in s:
 cs.add(r)
 return [r for r in subset if r in cs]
 def branch(repo, subset, x):
+"""``branch(set)``
+All changesets belonging to the branches of changesets in set.
+"""
 s = getset(repo, range(len(repo)), x)
 b = set()
 for r in s:
 b.add(repo[r].branch())
 s = set(s)
 return [r for r in subset if r in s or repo[r].branch() in b]
 def ancestor(repo, subset, x):
+"""``ancestor(single, single)``
+Greatest common ancestor of the two changesets.
+"""
 # i18n: "ancestor" is a keyword
 l = getargs(x, 2, 2, _("ancestor requires two arguments"))
 r = range(len(repo))
 a = getset(repo, r, l[0])
 b = getset(repo, r, l[1])
 an = [repo[a[0]].ancestor(repo[b[0]]).rev()]
 return [r for r in an if r in subset]
 def ancestors(repo, subset, x):
+"""``ancestors(set)``
+Changesets that are ancestors of a changeset in set.
+"""
 args = getset(repo, range(len(repo)), x)
 if not args:
 return []
 s = set(repo.changelog.ancestors(*args)) | set(args)
 return [r for r in subset if r in s]
 def descendants(repo, subset, x):
+"""``descendants(set)``
+Changesets which are descendants of changesets in set.
+"""
 args = getset(repo, range(len(repo)), x)
 if not args:
 return []
 s = set(repo.changelog.descendants(*args)) | set(args)
 return [r for r in subset if r in s]
 def follow(repo, subset, x):
+"""``follow()``
+An alias for ``::.`` (ancestors of the working copy's first parent).
+"""
 # i18n: "follow" is a keyword
 getargs(x, 0, 0, _("follow takes no arguments"))
 p = repo['.'].rev()
 s = set(repo.changelog.ancestors(p)) | set([p])
 return [r for r in subset if r in s]
 def date(repo, subset, x):
+"""``date(interval)``
+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 [r for r in subset if dm(repo[r].date()[0])]
 def keyword(repo, subset, x):
+"""``keyword(string)``
+Search commit message, user name, and names of changed files for
+string.
+"""
 # i18n: "keyword" is a keyword
 kw = getstring(x, _("keyword requires a string")).lower()
 l = []
 for r in subset:
 c = repo[r]
 if kw in t.lower():
 l.append(r)
 return l
 def grep(repo, subset, x):
+"""``grep(regex)``
+Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
+to ensure special escape characters are handled correctly.
+"""
 try:
 # i18n: "grep" is a keyword
 gr = re.compile(getstring(x, _("grep requires a string")))
 except re.error, e:
 raise error.ParseError(_('invalid match pattern: %s') % e)
 l.append(r)
 continue
 return l
 def author(repo, subset, x):
+"""``author(string)``
+Alias for ``user(string)``.
+"""
 # i18n: "author" is a keyword
 n = getstring(x, _("author requires a string")).lower()
 return [r for r in subset if n in repo[r].user().lower()]
+def user(repo, subset, x):
+"""``user(string)``
+User name is string.
+"""
+return author(repo, subset, x)
 def hasfile(repo, subset, x):
+"""``file(pattern)``
+Changesets affecting files matched by pattern.
+"""
 # i18n: "file" is a keyword
 pat = getstring(x, _("file requires a pattern"))
 m = matchmod.match(repo.root, repo.getcwd(), [pat])
 s = []
 for r in subset:
 s.append(r)
 continue
 return s
 def contains(repo, subset, x):
+"""``contains(pattern)``
+Revision contains pattern.
+"""
 # i18n: "contains" is a keyword
 pat = getstring(x, _("contains requires a pattern"))
 m = matchmod.match(repo.root, repo.getcwd(), [pat])
 s = []
 if m.files() == [pat]:
 s.append(r)
 continue
 return s
 def modifies(repo, subset, x):
+"""``modifies(pattern)``
+Changesets modifying files matched by pattern.
+"""
 # i18n: "modifies" is a keyword
 pat = getstring(x, _("modifies requires a pattern"))
 return checkstatus(repo, subset, pat, 0)
 def adds(repo, subset, x):
+"""``adds(pattern)``
+Changesets that add a file matching pattern.
+"""
 # i18n: "adds" is a keyword
 pat = getstring(x, _("adds requires a pattern"))
 return checkstatus(repo, subset, pat, 1)
 def removes(repo, subset, x):
+"""``removes(pattern)``
+Changesets which remove files matching pattern.
+"""
 # i18n: "removes" is a keyword
 pat = getstring(x, _("removes requires a pattern"))
 return checkstatus(repo, subset, pat, 2)
 def merge(repo, subset, x):
+"""``merge()``
+Changeset is a merge changeset.
+"""
 # i18n: "merge" is a keyword
 getargs(x, 0, 0, _("merge takes no arguments"))
 cl = repo.changelog
 return [r for r in subset if cl.parentrevs(r)[1] != -1]
 def closed(repo, subset, x):
+"""``closed()``
+Changeset is closed.
+"""
 # i18n: "closed" is a keyword
 getargs(x, 0, 0, _("closed takes no arguments"))
 return [r for r in subset if repo[r].extra().get('close')]
 def head(repo, subset, x):
+"""``head()``
+Changeset is a named branch head.
+"""
 # i18n: "head" is a keyword
 getargs(x, 0, 0, _("head takes no arguments"))
 hs = set()
 for b, ls in repo.branchmap().iteritems():
 hs.update(repo[h].rev() for h in ls)
 return [r for r in subset if r in hs]
 def reverse(repo, subset, x):
+"""``reverse(set)``
+Reverse order of set.
+"""
 l = getset(repo, subset, x)
 l.reverse()
 return l
 def present(repo, subset, x):
+"""``present(set)``
+An empty set, if any revision in set isn't found; otherwise,
+all revisions in set.
+"""
 try:
 return getset(repo, subset, x)
 except error.RepoLookupError:
 return []
 def sort(repo, subset, x):
+"""``sort(set[, [-]key...])``
+Sort set by keys. The default sort order is ascending, specify a key
+as ``-key`` to sort in descending order.
+The keys can be:
+- ``rev`` for the revision number,
+- ``branch`` for the branch name,
+- ``desc`` for the commit message (description),
+- ``user`` for user name (``author`` can be used as an alias),
+- ``date`` for the commit date
+"""
 # i18n: "sort" is a keyword
 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
 keys = "rev"
 if len(l) == 2:
 keys = getstring(l[1], _("sort spec must be a string"))
 l.append(e)
 l.sort()
 return [e[-1] for e in l]
 def getall(repo, subset, x):
+"""``all()``
+All changesets, the same as ``0:tip``.
+"""
 # i18n: "all" is a keyword
 getargs(x, 0, 0, _("all takes no arguments"))
 return subset
 def heads(repo, subset, x):
+"""``heads(set)``
+Members of set with no children in set.
+"""
 s = getset(repo, subset, x)
 ps = set(parents(repo, subset, x))
 return [r for r in s if r not in ps]
 def roots(repo, subset, x):
+"""``roots(set)``
+Changesets with no parent changeset in set.
+"""
 s = getset(repo, subset, x)
 cs = set(children(repo, subset, x))
 return [r for r in s if r not in cs]
 def outgoing(repo, subset, x):
+"""``outgoing([path])``
+Changesets not found in the specified destination repository, or the
+default push location.
+"""
 import hg # avoid start-up nasties
 # i18n: "outgoing" is a keyword
 l = getargs(x, 0, 1, _("outgoing requires a repository path"))
 # i18n: "outgoing" is a keyword
 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
 cl = repo.changelog
 o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, revs)[0]])
 return [r for r in subset if r in o]
 def tag(repo, subset, x):
+"""``tag(name)``
+The specified tag by name, or all tagged revisions if no name is given.
+"""
 # i18n: "tag" is a keyword
 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
 cl = repo.changelog
 if args:
 tn = getstring(args[0],
 _('the argument to tag must be a string'))
 s = set([cl.rev(n) for t, n in repo.tagslist() if t == tn])
 else:
 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
 return [r for r in subset if r in s]
+def tagged(repo, subset, x):
+return tag(repo, subset, x)
 symbols = {
 "adds": adds,
 "all": getall,
 "ancestor": ancestor,
 "reverse": reverse,
 "rev": rev,
 "roots": roots,
 "sort": sort,
 "tag": tag,
-"tagged": tag,
+"tagged": tagged,
-"user": author,
+"user": user,
 }
 methods = {
 "range": rangeset,
 "string": stringset,
 tree = parse(spec)
 weight, tree = optimize(tree, True)
 def mfunc(repo, subset):
 return getset(repo, subset, tree)
 return mfunc
+def makedoc(topic, doc):
+"""Generate and include predicates help in revsets topic."""
+predicates = []
+for name in sorted(symbols):
+text = symbols[name].__doc__
+if not text:
+continue
+lines = text.splitlines()
+lines[1:] = [('  ' + l.strip()) for l in lines[1:]]
+predicates.append('\n'.join(lines))
+predicates = '\n'.join(predicates)
+doc = doc.replace('.. predicatesmarker', predicates)
+return doc

branch	stable
changeset 12821	165079e564f0
parent 12815	079a618ea89d
child 12823	80deae3bc5ea