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

annotate mercurial/revset.py @ 20288:b61ad01c4e73

revset: use "canonpath()" for "filelog()" pattern without explicit kind Before this patch, revset predicate "filelog()" uses "match.files()" to get filename also for the pattern without explicit kind. But in such case, only canonicalization of relative path is required, and other initializations of "match" object including regexp compilation are meaningless. This patch uses "pathutil.canonpath()" directly for "filelog()" pattern without explicit kind like "glob:", for efficiency. This patch also does below as a part of introducing "canonpath()": - move location of "matchmod.match()" invocation, because "m" is no more used in "if not matchmod.patkind(pat)" code path - omit passing "default" argument to "matchmod.match()", because "pat" should have explicit kind of pattern in this code path

author	FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
date	Fri, 17 Jan 2014 23:55:03 +0900
parents	f3cef19befb1
children	96be25f1da45

rev	line source
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1 # revset.py - revision set queries for mercurial
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2 #
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	3 # Copyright 2010 Matt Mackall <mpm@selenic.com>
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	4 #
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	5 # This software may be used and distributed according to the terms of the
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	6 # GNU General Public License version 2 or any later version.
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	7
16834 cafd8a8fb713 util: subclass deque for Python 2.4 backwards compatibility Bryan O'Sullivan <bryano@fb.com> parents: 16825 diff changeset	8 import re
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	9 import parser, util, error, discovery, hbisect, phases
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	10 import node
12085 6f833fc3ccab Consistently import foo as foomod when foo to avoid shadowing Martin Geisler <mg@aragost.com> parents: 11944 diff changeset	11 import match as matchmod
13593 cc4721ed7a2a help: extract items doc generation function Patrick Mezard <pmezard@gmail.com> parents: 13506 diff changeset	12 from i18n import _
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	13 import encoding
17469 fb72eec7efd8 obsolete: introduce caches for all meaningful sets Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17424 diff changeset	14 import obsolete as obsmod
20286 760151697a4f revset: make default kind of pattern for "contains()" rooted at cwd FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20285 diff changeset	15 import pathutil
18251 a6483f827512 revset: retrieve hidden from filteredrevs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 18071 diff changeset	16 import repoview
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	17
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	18 def _revancestors(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	19 """Like revlog.ancestors(), but supports followfirst."""
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	20 cut = followfirst and 1 or None
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	21 cl = repo.changelog
16834 cafd8a8fb713 util: subclass deque for Python 2.4 backwards compatibility Bryan O'Sullivan <bryano@fb.com> parents: 16825 diff changeset	22 visit = util.deque(revs)
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	23 seen = set([node.nullrev])
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	24 while visit:
16803 107a3270a24a cleanup: use the deque type where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16778 diff changeset	25 for parent in cl.parentrevs(visit.popleft())[:cut]:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	26 if parent not in seen:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	27 visit.append(parent)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	28 seen.add(parent)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	29 yield parent
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	30
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	31 def _revdescendants(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	32 """Like revlog.descendants() but supports followfirst."""
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	33 cut = followfirst and 1 or None
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	34 cl = repo.changelog
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	35 first = min(revs)
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	36 nullrev = node.nullrev
b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	37 if first == nullrev:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	38 # Are there nodes with a null first parent and a non-null
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	39 # second one? Maybe. Do we care? Probably not.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	40 for i in cl:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	41 yield i
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	42 return
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	43
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	44 seen = set(revs)
17804 5a511d255301 clfilter: remove use of xrange in revset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17786 diff changeset	45 for i in cl.revs(first + 1):
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	46 for x in cl.parentrevs(i)[:cut]:
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	47 if x != nullrev and x in seen:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	48 seen.add(i)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	49 yield i
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	50 break
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	51
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	52 def _revsbetween(repo, roots, heads):
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	53 """Return all paths between roots and heads, inclusive of both endpoint
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	54 sets."""
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	55 if not roots:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	56 return []
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	57 parentrevs = repo.changelog.parentrevs
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	58 visit = heads[:]
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	59 reachable = set()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	60 seen = {}
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	61 minroot = min(roots)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	62 roots = set(roots)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	63 # open-code the post-order traversal due to the tiny size of
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	64 # sys.getrecursionlimit()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	65 while visit:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	66 rev = visit.pop()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	67 if rev in roots:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	68 reachable.add(rev)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	69 parents = parentrevs(rev)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	70 seen[rev] = parents
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	71 for parent in parents:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	72 if parent >= minroot and parent not in seen:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	73 visit.append(parent)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	74 if not reachable:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	75 return []
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	76 for rev in sorted(seen):
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	77 for parent in seen[rev]:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	78 if parent in reachable:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	79 reachable.add(rev)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	80 return sorted(reachable)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	81
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	82 elements = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	83 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	84 "~": (18, None, ("ancestor", 18)),
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	85 "^": (18, None, ("parent", 18), ("parentpost", 18)),
12616 e797fdf91df4 revset: lower precedence of minus infix (issue2361) Matt Mackall <mpm@selenic.com> parents: 12615 diff changeset	86 "-": (5, ("negate", 19), ("minus", 5)),
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	87 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	88 ("dagrangepost", 17)),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	89 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	90 ("dagrangepost", 17)),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	91 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	92 "not": (10, ("not", 10)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	93 "!": (10, ("not", 10)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	94 "and": (5, None, ("and", 5)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	95 "&": (5, None, ("and", 5)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	96 "or": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	97 "\|": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	98 "+": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	99 ",": (2, None, ("list", 2)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	100 ")": (0, None, None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	101 "symbol": (0, ("symbol",), None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	102 "string": (0, ("string",), None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	103 "end": (0, None, None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	104 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	105
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	106 keywords = set(['and', 'or', 'not'])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	107
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	108 def tokenize(program):
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	109 '''
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	110 Parse a revset statement into a stream of tokens
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	111
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	112 Check that @ is a valid unquoted token character (issue3686):
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	113 >>> list(tokenize("@::"))
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	114 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	115
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	116 '''
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	117
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	118 pos, l = 0, len(program)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	119 while pos < l:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	120 c = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	121 if c.isspace(): # skip inter-token whitespace
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	122 pass
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	123 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	124 yield ('::', None, pos)
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	125 pos += 1 # skip ahead
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	126 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	127 yield ('..', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	128 pos += 1 # skip ahead
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	129 elif c in "():,-\|&+!~^": # handle simple operators
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	130 yield (c, None, pos)
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	131 elif (c in '"\'' or c == 'r' and
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	132 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	133 if c == 'r':
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	134 pos += 1
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	135 c = program[pos]
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	136 decode = lambda x: x
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	137 else:
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	138 decode = lambda x: x.decode('string-escape')
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	139 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	140 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	141 while pos < l: # find closing quote
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	142 d = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	143 if d == '\\': # skip over escaped characters
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	144 pos += 2
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	145 continue
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	146 if d == c:
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	147 yield ('string', decode(program[s:pos]), s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	148 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	149 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	150 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	151 raise error.ParseError(_("unterminated string"), s)
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	152 # gather up a symbol/keyword
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	153 elif c.isalnum() or c in '._@' or ord(c) > 127:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	154 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	155 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	156 while pos < l: # find end of symbol
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	157 d = program[pos]
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	158 if not (d.isalnum() or d in "._/@" or ord(d) > 127):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	159 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	160 if d == '.' and program[pos - 1] == '.': # special case for ..
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	161 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	162 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	163 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	164 sym = program[s:pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	165 if sym in keywords: # operator keywords
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	166 yield (sym, None, s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	167 else:
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	168 yield ('symbol', sym, s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	169 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	170 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	171 raise error.ParseError(_("syntax error"), pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	172 pos += 1
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	173 yield ('end', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	174
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	175 # helpers
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	176
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	177 def getstring(x, err):
11406 42408cd43f55 revset: fix up contains/getstring when no args passed Matt Mackall <mpm@selenic.com> parents: 11404 diff changeset	178 if x and (x[0] == 'string' or x[0] == 'symbol'):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	179 return x[1]
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	180 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	181
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	182 def getlist(x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	183 if not x:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	184 return []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	185 if x[0] == 'list':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	186 return getlist(x[1]) + [x[2]]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	187 return [x]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	188
11339 744d5b73f776 revset: improve filter argument handling Matt Mackall <mpm@selenic.com> parents: 11304 diff changeset	189 def getargs(x, min, max, err):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	190 l = getlist(x)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	191 if len(l) < min or (max >= 0 and len(l) > max):
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	192 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	193 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	194
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	195 def getset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	196 if not x:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	197 raise error.ParseError(_("missing argument"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	198 return methods[x[0]](repo, subset, *x[1:])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	199
17003 42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	200 def _getrevsource(repo, r):
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	201 extra = repo[r].extra()
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	202 for label in ('source', 'transplant_source', 'rebase_source'):
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	203 if label in extra:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	204 try:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	205 return repo[extra[label]].rev()
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	206 except error.RepoLookupError:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	207 pass
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	208 return None
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	209
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	210 # operator methods
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	211
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	212 def stringset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	213 x = repo[x].rev()
11282 e581f3acc338 revset: fix up tests Matt Mackall <mpm@selenic.com> parents: 11280 diff changeset	214 if x == -1 and len(subset) == len(repo):
e581f3acc338 revset: fix up tests Matt Mackall <mpm@selenic.com> parents: 11280 diff changeset	215 return [-1]
13938 e44ebd2a142a revset: optimize stringset when subset == entire repo Idan Kamara <idankk86@gmail.com> parents: 13932 diff changeset	216 if len(subset) == len(repo) or x in subset:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	217 return [x]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	218 return []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	219
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	220 def symbolset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	221 if x in symbols:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	222 raise error.ParseError(_("can't use %s here") % x)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	223 return stringset(repo, subset, x)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	224
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	225 def rangeset(repo, subset, x, y):
18473 692cbda1eb50 revset: evaluate sub expressions correctly (issue3775) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18411 diff changeset	226 cl = repo.changelog
692cbda1eb50 revset: evaluate sub expressions correctly (issue3775) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18411 diff changeset	227 m = getset(repo, cl, x)
692cbda1eb50 revset: evaluate sub expressions correctly (issue3775) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18411 diff changeset	228 n = getset(repo, cl, y)
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	229
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	230 if not m or not n:
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	231 return []
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	232 m, n = m[0], n[-1]
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	233
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	234 if m < n:
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	235 r = range(m, n + 1)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	236 else:
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	237 r = range(m, n - 1, -1)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	238 s = set(subset)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	239 return [x for x in r if x in s]
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	240
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	241 def dagrange(repo, subset, x, y):
18991 c1af1fb314bc log: fix behavior with empty repositories (issue3497) Alexander Plavin <me@aplavin.ru> parents: 18779 diff changeset	242 r = list(repo)
c1af1fb314bc log: fix behavior with empty repositories (issue3497) Alexander Plavin <me@aplavin.ru> parents: 18779 diff changeset	243 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
c1af1fb314bc log: fix behavior with empty repositories (issue3497) Alexander Plavin <me@aplavin.ru> parents: 18779 diff changeset	244 s = set(subset)
c1af1fb314bc log: fix behavior with empty repositories (issue3497) Alexander Plavin <me@aplavin.ru> parents: 18779 diff changeset	245 return [r for r in xs if r in s]
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	246
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	247 def andset(repo, subset, x, y):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	248 return getset(repo, getset(repo, subset, x), y)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	249
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	250 def orset(repo, subset, x, y):
13932 34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	251 xl = getset(repo, subset, x)
34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	252 s = set(xl)
34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	253 yl = getset(repo, [r for r in subset if r not in s], y)
34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	254 return xl + yl
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	255
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	256 def notset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	257 s = set(getset(repo, subset, x))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	258 return [r for r in subset if r not in s]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	259
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	260 def listset(repo, subset, a, b):
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	261 raise error.ParseError(_("can't use a list in this context"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	262
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	263 def func(repo, subset, a, b):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	264 if a[0] == 'symbol' and a[1] in symbols:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	265 return symbols[a[1]](repo, subset, b)
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	266 raise error.ParseError(_("not a function: %s") % a[1])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	267
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	268 # functions
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	269
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	270 def adds(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	271 """``adds(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	272 Changesets that add a file matching pattern.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	273 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	274 # i18n: "adds" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	275 pat = getstring(x, _("adds requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	276 return checkstatus(repo, subset, pat, 1)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	277
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	278 def ancestor(repo, subset, x):
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	279 """``ancestor(*changeset)``
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	280 Greatest common ancestor of the changesets.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	281
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	282 Accepts 0 or more changesets.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	283 Will return empty list when passed no args.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	284 Greatest common ancestor of a single changeset is that changeset.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	285 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	286 # i18n: "ancestor" is a keyword
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	287 l = getlist(x)
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	288 rl = list(repo)
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	289 anc = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	290
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	291 # (getset(repo, rl, i) for i in l) generates a list of lists
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	292 rev = repo.changelog.rev
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	293 ancestor = repo.changelog.ancestor
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	294 node = repo.changelog.node
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	295 for revs in (getset(repo, rl, i) for i in l):
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	296 for r in revs:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	297 if anc is None:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	298 anc = r
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	299 else:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	300 anc = rev(ancestor(node(anc), node(r)))
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	301
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	302 if anc is not None and anc in subset:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	303 return [anc]
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	304 return []
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	305
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	306 def _ancestors(repo, subset, x, followfirst=False):
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	307 args = getset(repo, list(repo), x)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	308 if not args:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	309 return []
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	310 s = set(_revancestors(repo, args, followfirst)) \| set(args)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	311 return [r for r in subset if r in s]
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	312
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	313 def ancestors(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	314 """``ancestors(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	315 Changesets that are ancestors of a changeset in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	316 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	317 return _ancestors(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	318
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	319 def _firstancestors(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	320 # ``_firstancestors(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	321 # Like ``ancestors(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	322 return _ancestors(repo, subset, x, followfirst=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	323
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	324 def ancestorspec(repo, subset, x, n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	325 """``set~n``
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	326 Changesets that are the Nth ancestor (first parents only) of a changeset
525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	327 in set.
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	328 """
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	329 try:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	330 n = int(n[1])
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	331 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	332 raise error.ParseError(_("~ expects a number"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	333 ps = set()
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	334 cl = repo.changelog
18473 692cbda1eb50 revset: evaluate sub expressions correctly (issue3775) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18411 diff changeset	335 for r in getset(repo, cl, x):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	336 for i in range(n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	337 r = cl.parentrevs(r)[0]
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	338 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	339 return [r for r in subset if r in ps]
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	340
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	341 def author(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	342 """``author(string)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	343 Alias for ``user(string)``.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	344 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	345 # i18n: "author" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	346 n = encoding.lower(getstring(x, _("author requires a string")))
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	347 kind, pattern, matcher = _substringmatcher(n)
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	348 return [r for r in subset if matcher(encoding.lower(repo[r].user()))]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	349
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	350 def bisect(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	351 """``bisect(string)``
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	352 Changesets marked in the specified bisect status:
15136 18219c0789ae revset.bisect: add new 'range' set to the bisect keyword "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15135 diff changeset	353
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	354 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
17424 e7cfe3587ea4 fix trivial spelling errors Mads Kiilerich <mads@kiilerich.com> parents: 17390 diff changeset	355 - ``goods``, ``bads`` : csets topologically good/bad
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	356 - ``range`` : csets taking part in the bisection
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	357 - ``pruned`` : csets that are goods, bads or skipped
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	358 - ``untested`` : csets whose fate is yet unknown
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	359 - ``ignored`` : csets ignored due to DAG topology
16647 14913fcb30c6 bisect: track the current changeset (issue3382) Bryan O'Sullivan <bryano@fb.com> parents: 16640 diff changeset	360 - ``current`` : the cset currently being bisected
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	361 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	362 # i18n: "bisect" is a keyword
15135 f19de58af225 revset.bisect: move bisect() code to hbisect.py "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15134 diff changeset	363 status = getstring(x, _("bisect requires a string")).lower()
16467 7f59900e3f8b revset: fix O(n*2) behaviour of bisect() (issue3381) Bryan O'Sullivan <bryano@fb.com>* parents: 16453 diff changeset	364 state = set(hbisect.get(repo, status))
7f59900e3f8b revset: fix O(n*2) behaviour of bisect() (issue3381) Bryan O'Sullivan <bryano@fb.com>* parents: 16453 diff changeset	365 return [r for r in subset if r in state]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	366
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	367 # Backward-compatibility
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	368 # - no help entry so that we do not advertise it any more
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	369 def bisected(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	370 return bisect(repo, subset, x)
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	371
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	372 def bookmark(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	373 """``bookmark([name])``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	374 The named bookmark or all bookmarks.
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	375
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	376 If `name` starts with `re:`, the remainder of the name is treated as
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	377 a regular expression. To match a bookmark that actually starts with `re:`,
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	378 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	379 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	380 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	381 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	382 if args:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	383 bm = getstring(args[0],
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	384 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	385 _('the argument to bookmark must be a string'))
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	386 kind, pattern, matcher = _stringmatcher(bm)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	387 if kind == 'literal':
18495 8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations Kevin Bullock <kbullock@ringworld.org> parents: 18473 diff changeset	388 bmrev = repo._bookmarks.get(bm, None)
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	389 if not bmrev:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	390 raise util.Abort(_("bookmark '%s' does not exist") % bm)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	391 bmrev = repo[bmrev].rev()
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	392 return [r for r in subset if r == bmrev]
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	393 else:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	394 matchrevs = set()
18495 8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations Kevin Bullock <kbullock@ringworld.org> parents: 18473 diff changeset	395 for name, bmrev in repo._bookmarks.iteritems():
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	396 if matcher(name):
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	397 matchrevs.add(bmrev)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	398 if not matchrevs:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	399 raise util.Abort(_("no bookmarks exist that match '%s'")
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	400 % pattern)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	401 bmrevs = set()
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	402 for bmrev in matchrevs:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	403 bmrevs.add(repo[bmrev].rev())
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	404 return [r for r in subset if r in bmrevs]
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	405
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	406 bms = set([repo[r].rev()
18495 8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations Kevin Bullock <kbullock@ringworld.org> parents: 18473 diff changeset	407 for r in repo._bookmarks.values()])
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	408 return [r for r in subset if r in bms]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	409
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	410 def branch(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	411 """``branch(string or set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	412 All changesets belonging to the given branch or the branches of the given
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	413 changesets.
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	414
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	415 If `string` starts with `re:`, the remainder of the name is treated as
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	416 a regular expression. To match a branch that actually starts with `re:`,
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	417 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	418 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	419 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	420 b = getstring(x, '')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	421 except error.ParseError:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	422 # not a string, but another revspec, e.g. tip()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	423 pass
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	424 else:
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	425 kind, pattern, matcher = _stringmatcher(b)
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	426 if kind == 'literal':
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	427 # note: falls through to the revspec case if no branch with
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	428 # this name exists
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	429 if pattern in repo.branchmap():
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	430 return [r for r in subset if matcher(repo[r].branch())]
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	431 else:
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	432 return [r for r in subset if matcher(repo[r].branch())]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	433
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	434 s = getset(repo, list(repo), x)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	435 b = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	436 for r in s:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	437 b.add(repo[r].branch())
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	438 s = set(s)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	439 return [r for r in subset if r in s or repo[r].branch() in b]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	440
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	441 def bumped(repo, subset, x):
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	442 """``bumped()``
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	443 Mutable changesets marked as successors of public changesets.
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	444
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	445 Only non-public and non-obsolete changesets can be `bumped`.
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	446 """
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	447 # i18n: "bumped" is a keyword
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	448 getargs(x, 0, 0, _("bumped takes no arguments"))
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	449 bumped = obsmod.getrevs(repo, 'bumped')
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	450 return [r for r in subset if r in bumped]
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	451
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	452 def bundle(repo, subset, x):
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	453 """``bundle()``
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	454 Changesets in the bundle.
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	455
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	456 Bundle must be specified by the -R option."""
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	457
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	458 try:
18411 8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression Mads Kiilerich <madski@unity3d.com> parents: 18382 diff changeset	459 bundlerevs = repo.changelog.bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	460 except AttributeError:
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	461 raise util.Abort(_("no bundle provided - specify with -R"))
18411 8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression Mads Kiilerich <madski@unity3d.com> parents: 18382 diff changeset	462 return [r for r in subset if r in bundlerevs]
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	463
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	464 def checkstatus(repo, subset, pat, field):
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	465 m = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	466 s = []
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	467 hasset = matchmod.patkind(pat) == 'set'
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	468 fname = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	469 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	470 c = repo[r]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	471 if not m or hasset:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	472 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	473 if not m.anypats() and len(m.files()) == 1:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	474 fname = m.files()[0]
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	475 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	476 if fname not in c.files():
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	477 continue
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	478 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	479 for f in c.files():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	480 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	481 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	482 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	483 continue
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	484 files = repo.status(c.p1().node(), c.node())[field]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	485 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	486 if fname in files:
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	487 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	488 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	489 for f in files:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	490 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	491 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	492 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	493 return s
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	494
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	495 def _children(repo, narrow, parentset):
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	496 cs = set()
18063 34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	497 if not parentset:
34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	498 return cs
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	499 pr = repo.changelog.parentrevs
18063 34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	500 minrev = min(parentset)
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	501 for r in narrow:
18063 34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	502 if r <= minrev:
34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	503 continue
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	504 for p in pr(r):
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	505 if p in parentset:
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	506 cs.add(r)
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	507 return cs
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	508
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	509 def children(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	510 """``children(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	511 Child changesets of changesets in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	512 """
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	513 s = set(getset(repo, list(repo), x))
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	514 cs = _children(repo, subset, s)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	515 return [r for r in subset if r in cs]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	516
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	517 def closed(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	518 """``closed()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	519 Changeset is closed.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	520 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	521 # i18n: "closed" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	522 getargs(x, 0, 0, _("closed takes no arguments"))
16720 e825a89de5d7 context: add changectx.closesbranch() method Brodie Rao <brodie@sf.io> parents: 16683 diff changeset	523 return [r for r in subset if repo[r].closesbranch()]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	524
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	525 def contains(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	526 """``contains(pattern)``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	527 Revision contains a file matching pattern. See :hg:`help patterns`
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	528 for information about file patterns.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	529 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	530 # i18n: "contains" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	531 pat = getstring(x, _("contains requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	532 s = []
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	533 if not matchmod.patkind(pat):
20286 760151697a4f revset: make default kind of pattern for "contains()" rooted at cwd FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20285 diff changeset	534 pat = pathutil.canonpath(repo.root, repo.getcwd(), pat)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	535 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	536 if pat in repo[r]:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	537 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	538 else:
20285 189fe1b3d16a revset: narrow scope of the variable referred only in specific code path FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20208 diff changeset	539 m = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	540 for r in subset:
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	541 c = repo[r]
6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	542 if not m or matchmod.patkind(pat) == 'set':
6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	543 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	544 for f in c.manifest():
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	545 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	546 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	547 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	548 return s
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	549
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	550 def converted(repo, subset, x):
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	551 """``converted([id])``
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	552 Changesets converted from the given identifier in the old repository if
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	553 present, or all converted changesets if no identifier is specified.
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	554 """
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	555
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	556 # There is exactly no chance of resolving the revision, so do a simple
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	557 # string compare and hope for the best
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	558
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	559 rev = None
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	560 # i18n: "converted" is a keyword
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	561 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	562 if l:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	563 # i18n: "converted" is a keyword
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	564 rev = getstring(l[0], _('converted requires a revision'))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	565
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	566 def _matchvalue(r):
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	567 source = repo[r].extra().get('convert_revision', None)
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	568 return source is not None and (rev is None or source.startswith(rev))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	569
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	570 return [r for r in subset if _matchvalue(r)]
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	571
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	572 def date(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	573 """``date(interval)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	574 Changesets within the interval, see :hg:`help dates`.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	575 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	576 # i18n: "date" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	577 ds = getstring(x, _("date requires a string"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	578 dm = util.matchdate(ds)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	579 return [r for r in subset if dm(repo[r].date()[0])]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	580
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	581 def desc(repo, subset, x):
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	582 """``desc(string)``
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	583 Search commit message for string. The match is case-insensitive.
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	584 """
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	585 # i18n: "desc" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	586 ds = encoding.lower(getstring(x, _("desc requires a string")))
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	587 l = []
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	588 for r in subset:
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	589 c = repo[r]
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	590 if ds in encoding.lower(c.description()):
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	591 l.append(r)
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	592 return l
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	593
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	594 def _descendants(repo, subset, x, followfirst=False):
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	595 args = getset(repo, list(repo), x)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	596 if not args:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	597 return []
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	598 s = set(_revdescendants(repo, args, followfirst)) \| set(args)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	599 return [r for r in subset if r in s]
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	600
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	601 def descendants(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	602 """``descendants(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	603 Changesets which are descendants of changesets in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	604 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	605 return _descendants(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	606
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	607 def _firstdescendants(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	608 # ``_firstdescendants(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	609 # Like ``descendants(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	610 return _descendants(repo, subset, x, followfirst=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	611
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	612 def destination(repo, subset, x):
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	613 """``destination([set])``
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	614 Changesets that were created by a graft, transplant or rebase operation,
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	615 with the given revisions specified as the source. Omitting the optional set
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	616 is the same as passing all().
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	617 """
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	618 if x is not None:
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	619 args = set(getset(repo, list(repo), x))
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	620 else:
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	621 args = set(getall(repo, list(repo), x))
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	622
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	623 dests = set()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	624
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	625 # subset contains all of the possible destinations that can be returned, so
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	626 # iterate over them and see if their source(s) were provided in the args.
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	627 # Even if the immediate src of r is not in the args, src's source (or
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	628 # further back) may be. Scanning back further than the immediate src allows
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	629 # transitive transplants and rebases to yield the same results as transitive
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	630 # grafts.
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	631 for r in subset:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	632 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	633 lineage = None
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	634
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	635 while src is not None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	636 if lineage is None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	637 lineage = list()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	638
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	639 lineage.append(r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	640
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	641 # The visited lineage is a match if the current source is in the arg
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	642 # set. Since every candidate dest is visited by way of iterating
17494 74801685aaa2 spelling: further timeless@mozdev.org parents: 17291 diff changeset	643 # subset, any dests further back in the lineage will be tested by a
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	644 # different iteration over subset. Likewise, if the src was already
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	645 # selected, the current lineage can be selected without going back
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	646 # further.
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	647 if src in args or src in dests:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	648 dests.update(lineage)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	649 break
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	650
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	651 r = src
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	652 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	653
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	654 return [r for r in subset if r in dests]
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	655
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	656 def divergent(repo, subset, x):
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	657 """``divergent()``
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	658 Final successors of changesets with an alternative set of final successors.
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	659 """
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	660 # i18n: "divergent" is a keyword
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	661 getargs(x, 0, 0, _("divergent takes no arguments"))
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	662 divergent = obsmod.getrevs(repo, 'divergent')
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	663 return [r for r in subset if r in divergent]
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	664
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	665 def draft(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	666 """``draft()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	667 Changeset in draft phase."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	668 # i18n: "draft" is a keyword
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	669 getargs(x, 0, 0, _("draft takes no arguments"))
16657 b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	670 pc = repo._phasecache
b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	671 return [r for r in subset if pc.phase(repo, r) == phases.draft]
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	672
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	673 def extinct(repo, subset, x):
c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	674 """``extinct()``
17291 2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	675 Obsolete changesets with obsolete descendants only.
2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	676 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	677 # i18n: "extinct" is a keyword
17258 5822345e9e46 revset: use appropriate predicate name in error messages FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17244 diff changeset	678 getargs(x, 0, 0, _("extinct takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	679 extincts = obsmod.getrevs(repo, 'extinct')
17469 fb72eec7efd8 obsolete: introduce caches for all meaningful sets Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17424 diff changeset	680 return [r for r in subset if r in extincts]
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	681
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	682 def extra(repo, subset, x):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	683 """``extra(label, [value])``
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	684 Changesets with the given label in the extra metadata, with the given
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	685 optional value.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	686
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	687 If `value` starts with `re:`, the remainder of the value is treated as
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	688 a regular expression. To match a value that actually starts with `re:`,
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	689 use the prefix `literal:`.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	690 """
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	691
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	692 # i18n: "extra" is a keyword
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	693 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	694 # i18n: "extra" is a keyword
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	695 label = getstring(l[0], _('first argument to extra must be a string'))
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	696 value = None
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	697
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	698 if len(l) > 1:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	699 # i18n: "extra" is a keyword
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	700 value = getstring(l[1], _('second argument to extra must be a string'))
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	701 kind, value, matcher = _stringmatcher(value)
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	702
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	703 def _matchvalue(r):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	704 extra = repo[r].extra()
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	705 return label in extra and (value is None or matcher(extra[label]))
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	706
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	707 return [r for r in subset if _matchvalue(r)]
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	708
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	709 def filelog(repo, subset, x):
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	710 """``filelog(pattern)``
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	711 Changesets connected to the specified filelog.
17244 483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17186 diff changeset	712
17265 c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	713 For performance reasons, ``filelog()`` does not show every changeset
c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	714 that affects the requested file(s). See :hg:`help log` for details. For
c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	715 a slower, more accurate result, use ``file()``.
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	716 """
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	717
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	718 # i18n: "filelog" is a keyword
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	719 pat = getstring(x, _("filelog requires a pattern"))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	720 s = set()
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	721
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	722 if not matchmod.patkind(pat):
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	723 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
20287 f3cef19befb1 revset: avoid loop for "match.files()" having always one element for efficiency FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20286 diff changeset	724 fl = repo.file(f)
f3cef19befb1 revset: avoid loop for "match.files()" having always one element for efficiency FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20286 diff changeset	725 for fr in fl:
f3cef19befb1 revset: avoid loop for "match.files()" having always one element for efficiency FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20286 diff changeset	726 s.add(fl.linkrev(fr))
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	727 else:
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	728 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	729 for f in repo[None]:
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	730 if m(f):
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	731 fl = repo.file(f)
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	732 for fr in fl:
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	733 s.add(fl.linkrev(fr))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	734
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	735 return [r for r in subset if r in s]
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	736
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	737 def first(repo, subset, x):
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	738 """``first(set, [n])``
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	739 An alias for limit().
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	740 """
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	741 return limit(repo, subset, x)
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	742
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	743 def _follow(repo, subset, x, name, followfirst=False):
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	744 l = getargs(x, 0, 1, _("%s takes no arguments or a filename") % name)
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	745 c = repo['.']
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	746 if l:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	747 x = getstring(l[0], _("%s expected a filename") % name)
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	748 if x in c:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	749 cx = c[x]
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	750 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	751 # include the revision responsible for the most recent version
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	752 s.add(cx.linkrev())
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	753 else:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	754 return []
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	755 else:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	756 s = set(_revancestors(repo, [c.rev()], followfirst)) \| set([c.rev()])
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	757
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	758 return [r for r in subset if r in s]
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	759
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	760 def follow(repo, subset, x):
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	761 """``follow([file])``
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	762 An alias for ``::.`` (ancestors of the working copy's first parent).
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	763 If a filename is specified, the history of the given file is followed,
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	764 including copies.
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	765 """
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	766 return _follow(repo, subset, x, 'follow')
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	767
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	768 def _followfirst(repo, subset, x):
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	769 # ``followfirst([file])``
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	770 # Like ``follow([file])`` but follows only the first parent of
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	771 # every revision or file revision.
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	772 return _follow(repo, subset, x, '_followfirst', followfirst=True)
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	773
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	774 def getall(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	775 """``all()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	776 All changesets, the same as ``0:tip``.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	777 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	778 # i18n: "all" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	779 getargs(x, 0, 0, _("all takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	780 return subset
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	781
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	782 def grep(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	783 """``grep(regex)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	784 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	785 to ensure special escape characters are handled correctly. Unlike
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	786 ``keyword(string)``, the match is case-sensitive.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	787 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	788 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	789 # i18n: "grep" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	790 gr = re.compile(getstring(x, _("grep requires a string")))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	791 except re.error, e:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	792 raise error.ParseError(_('invalid match pattern: %s') % e)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	793 l = []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	794 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	795 c = repo[r]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	796 for e in c.files() + [c.user(), c.description()]:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	797 if gr.search(e):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	798 l.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	799 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	800 return l
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	801
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	802 def _matchfiles(repo, subset, x):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	803 # _matchfiles takes a revset list of prefixed arguments:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	804 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	805 # [p:foo, i:bar, x:baz]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	806 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	807 # builds a match object from them and filters subset. Allowed
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	808 # prefixes are 'p:' for regular patterns, 'i:' for include
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	809 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	810 # a revision identifier, or the empty string to reference the
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	811 # working directory, from which the match object is
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	812 # initialized. Use 'd:' to set the default matching mode, default
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	813 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	814
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	815 # i18n: "_matchfiles" is a keyword
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	816 l = getargs(x, 1, -1, _("_matchfiles requires at least one argument"))
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	817 pats, inc, exc = [], [], []
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	818 hasset = False
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	819 rev, default = None, None
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	820 for arg in l:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	821 # i18n: "_matchfiles" is a keyword
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	822 s = getstring(arg, _("_matchfiles requires string arguments"))
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	823 prefix, value = s[:2], s[2:]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	824 if prefix == 'p:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	825 pats.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	826 elif prefix == 'i:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	827 inc.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	828 elif prefix == 'x:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	829 exc.append(value)
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	830 elif prefix == 'r:':
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	831 if rev is not None:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	832 # i18n: "_matchfiles" is a keyword
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	833 raise error.ParseError(_('_matchfiles expected at most one '
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	834 'revision'))
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	835 rev = value
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	836 elif prefix == 'd:':
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	837 if default is not None:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	838 # i18n: "_matchfiles" is a keyword
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	839 raise error.ParseError(_('_matchfiles expected at most one '
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	840 'default mode'))
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	841 default = value
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	842 else:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	843 # i18n: "_matchfiles" is a keyword
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	844 raise error.ParseError(_('invalid _matchfiles prefix: %s') % prefix)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	845 if not hasset and matchmod.patkind(value) == 'set':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	846 hasset = True
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	847 if not default:
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	848 default = 'glob'
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	849 m = None
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	850 s = []
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	851 for r in subset:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	852 c = repo[r]
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	853 if not m or (hasset and rev is None):
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	854 ctx = c
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	855 if rev is not None:
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	856 ctx = repo[rev or None]
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	857 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	858 exclude=exc, ctx=ctx, default=default)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	859 for f in c.files():
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	860 if m(f):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	861 s.append(r)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	862 break
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	863 return s
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	864
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	865 def hasfile(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	866 """``file(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	867 Changesets affecting files matched by pattern.
17244 483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17186 diff changeset	868
17265 c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	869 For a faster but less accurate result, consider using ``filelog()``
c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	870 instead.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	871 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	872 # i18n: "file" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	873 pat = getstring(x, _("file requires a pattern"))
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	874 return _matchfiles(repo, subset, ('string', 'p:' + pat))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	875
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	876 def head(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	877 """``head()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	878 Changeset is a named branch head.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	879 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	880 # i18n: "head" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	881 getargs(x, 0, 0, _("head takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	882 hs = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	883 for b, ls in repo.branchmap().iteritems():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	884 hs.update(repo[h].rev() for h in ls)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	885 return [r for r in subset if r in hs]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	886
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	887 def heads(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	888 """``heads(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	889 Members of set with no children in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	890 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	891 s = getset(repo, subset, x)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	892 ps = set(parents(repo, subset, x))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	893 return [r for r in s if r not in ps]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	894
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	895 def hidden(repo, subset, x):
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	896 """``hidden()``
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	897 Hidden changesets.
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	898 """
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	899 # i18n: "hidden" is a keyword
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	900 getargs(x, 0, 0, _("hidden takes no arguments"))
18382 f3b21beb9802 filtering: rename filters to their antonyms Kevin Bullock <kbullock@ringworld.org> parents: 18251 diff changeset	901 hiddenrevs = repoview.filterrevs(repo, 'visible')
18251 a6483f827512 revset: retrieve hidden from filteredrevs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 18071 diff changeset	902 return [r for r in subset if r in hiddenrevs]
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	903
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	904 def keyword(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	905 """``keyword(string)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	906 Search commit message, user name, and names of changed files for
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	907 string. The match is case-insensitive.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	908 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	909 # i18n: "keyword" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	910 kw = encoding.lower(getstring(x, _("keyword requires a string")))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	911 l = []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	912 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	913 c = repo[r]
19706 26ddce1a2a55 revset: fix wrong keyword() behaviour for strings with spaces Alexander Plavin <alexander@plav.in> parents: 18991 diff changeset	914 if util.any(kw in encoding.lower(t)
26ddce1a2a55 revset: fix wrong keyword() behaviour for strings with spaces Alexander Plavin <alexander@plav.in> parents: 18991 diff changeset	915 for t in c.files() + [c.user(), c.description()]):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	916 l.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	917 return l
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	918
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	919 def limit(repo, subset, x):
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	920 """``limit(set, [n])``
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	921 First n members of set, defaulting to 1.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	922 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	923 # i18n: "limit" is a keyword
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	924 l = getargs(x, 1, 2, _("limit requires one or two arguments"))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	925 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	926 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	927 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	928 # i18n: "limit" is a keyword
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	929 lim = int(getstring(l[1], _("limit requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	930 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	931 # i18n: "limit" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	932 raise error.ParseError(_("limit expects a number"))
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	933 ss = set(subset)
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	934 os = getset(repo, list(repo), l[0])[:lim]
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	935 return [r for r in os if r in ss]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	936
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	937 def last(repo, subset, x):
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	938 """``last(set, [n])``
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	939 Last n members of set, defaulting to 1.
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	940 """
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	941 # i18n: "last" is a keyword
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	942 l = getargs(x, 1, 2, _("last requires one or two arguments"))
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	943 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	944 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	945 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	946 # i18n: "last" is a keyword
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	947 lim = int(getstring(l[1], _("last requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	948 except (TypeError, ValueError):
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	949 # i18n: "last" is a keyword
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	950 raise error.ParseError(_("last expects a number"))
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	951 ss = set(subset)
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	952 os = getset(repo, list(repo), l[0])[-lim:]
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	953 return [r for r in os if r in ss]
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	954
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	955 def maxrev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	956 """``max(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	957 Changeset with highest revision number in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	958 """
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	959 os = getset(repo, list(repo), x)
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	960 if os:
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	961 m = max(os)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	962 if m in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	963 return [m]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	964 return []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	965
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	966 def merge(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	967 """``merge()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	968 Changeset is a merge changeset.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	969 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	970 # i18n: "merge" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	971 getargs(x, 0, 0, _("merge takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	972 cl = repo.changelog
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	973 return [r for r in subset if cl.parentrevs(r)[1] != -1]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	974
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	975 def branchpoint(repo, subset, x):
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	976 """``branchpoint()``
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	977 Changesets with more than one child.
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	978 """
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	979 # i18n: "branchpoint" is a keyword
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	980 getargs(x, 0, 0, _("branchpoint takes no arguments"))
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	981 cl = repo.changelog
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	982 if not subset:
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	983 return []
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	984 baserev = min(subset)
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	985 parentscount = [0]*(len(repo) - baserev)
17785 ac5c9c8046f7 clfilter: use changelog to iterate over the repo in branchpoint Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17753 diff changeset	986 for r in cl.revs(start=baserev + 1):
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	987 for p in cl.parentrevs(r):
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	988 if p >= baserev:
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	989 parentscount[p - baserev] += 1
17786 72c234081ae1 branchpoint: remove useless intermediate set creation Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17785 diff changeset	990 return [r for r in subset if (parentscount[r - baserev] > 1)]
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	991
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	992 def minrev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	993 """``min(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	994 Changeset with lowest revision number in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	995 """
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	996 os = getset(repo, list(repo), x)
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	997 if os:
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	998 m = min(os)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	999 if m in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1000 return [m]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1001 return []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1002
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1003 def modifies(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1004 """``modifies(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1005 Changesets modifying files matched by pattern.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1006 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1007 # i18n: "modifies" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1008 pat = getstring(x, _("modifies requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1009 return checkstatus(repo, subset, pat, 0)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1010
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1011 def node_(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1012 """``id(string)``
12859 76066903ae08 revset: fix missing dot in docstring Wagner Bruna <wbruna@yahoo.com> parents: 12855 diff changeset	1013 Revision non-ambiguously specified by the given hex string prefix.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1014 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1015 # i18n: "id" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1016 l = getargs(x, 1, 1, _("id requires one argument"))
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1017 # i18n: "id" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1018 n = getstring(l[0], _("id requires a string"))
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1019 if len(n) == 40:
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1020 rn = repo[n].rev()
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1021 else:
16735 47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1022 rn = None
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1023 pm = repo.changelog._partialmatch(n)
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1024 if pm is not None:
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1025 rn = repo.changelog.rev(pm)
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1026
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1027 return [r for r in subset if r == rn]
c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1028
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1029 def obsolete(repo, subset, x):
63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1030 """``obsolete()``
63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1031 Mutable changeset with a newer version."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1032 # i18n: "obsolete" is a keyword
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1033 getargs(x, 0, 0, _("obsolete takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	1034 obsoletes = obsmod.getrevs(repo, 'obsolete')
17469 fb72eec7efd8 obsolete: introduce caches for all meaningful sets Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17424 diff changeset	1035 return [r for r in subset if r in obsoletes]
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1036
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1037 def origin(repo, subset, x):
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1038 """``origin([set])``
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1039 Changesets that were specified as a source for the grafts, transplants or
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1040 rebases that created the given revisions. Omitting the optional set is the
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1041 same as passing all(). If a changeset created by these operations is itself
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1042 specified as a source for one of these operations, only the source changeset
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1043 for the first operation is selected.
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1044 """
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1045 if x is not None:
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	1046 args = set(getset(repo, list(repo), x))
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1047 else:
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	1048 args = set(getall(repo, list(repo), x))
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1049
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1050 def _firstsrc(rev):
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1051 src = _getrevsource(repo, rev)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1052 if src is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1053 return None
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1054
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1055 while True:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1056 prev = _getrevsource(repo, src)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1057
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1058 if prev is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1059 return src
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1060 src = prev
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1061
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1062 o = set([_firstsrc(r) for r in args])
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1063 return [r for r in subset if r in o]
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1064
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1065 def outgoing(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1066 """``outgoing([path])``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1067 Changesets not found in the specified destination repository, or the
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1068 default push location.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1069 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1070 import hg # avoid start-up nasties
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1071 # i18n: "outgoing" is a keyword
14717 c8ee2729e89f revset and fileset: fix typos in parser error messages Mads Kiilerich <mads@kiilerich.com> parents: 14715 diff changeset	1072 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1073 # i18n: "outgoing" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1074 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1075 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1076 dest, branches = hg.parseurl(dest)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1077 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1078 if revs:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1079 revs = [repo.lookup(rev) for rev in revs]
14556 517e1d88bf7e hg: change various repository() users to use peer() where appropriate Matt Mackall <mpm@selenic.com> parents: 14509 diff changeset	1080 other = hg.peer(repo, {}, dest)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1081 repo.ui.pushbuffer()
15837 cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15819 diff changeset	1082 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1083 repo.ui.popbuffer()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1084 cl = repo.changelog
15837 cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15819 diff changeset	1085 o = set([cl.rev(r) for r in outgoing.missing])
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1086 return [r for r in subset if r in o]
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1087
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1088 def p1(repo, subset, x):
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1089 """``p1([set])``
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1090 First parent of changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1091 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1092 if x is None:
13878 a8d13ee0ce68 misc: replace .parents()[0] with p1() Matt Mackall <mpm@selenic.com> parents: 13873 diff changeset	1093 p = repo[x].p1().rev()
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1094 return [r for r in subset if r == p]
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1095
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1096 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1097 cl = repo.changelog
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	1098 for r in getset(repo, list(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1099 ps.add(cl.parentrevs(r)[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1100 return [r for r in subset if r in ps]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1101
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1102 def p2(repo, subset, x):
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1103 """``p2([set])``
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1104 Second parent of changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1105 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1106 if x is None:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1107 ps = repo[x].parents()
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1108 try:
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1109 p = ps[1].rev()
98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1110 return [r for r in subset if r == p]
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1111 except IndexError:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1112 return []
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1113
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1114 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1115 cl = repo.changelog
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	1116 for r in getset(repo, list(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1117 ps.add(cl.parentrevs(r)[1])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1118 return [r for r in subset if r in ps]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1119
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1120 def parents(repo, subset, x):
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1121 """``parents([set])``
515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1122 The set of all parents for all changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1123 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1124 if x is None:
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1125 ps = tuple(p.rev() for p in repo[x].parents())
98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1126 return [r for r in subset if r in ps]
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1127
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1128 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1129 cl = repo.changelog
17675 8575f4a2126e clfilter: remove usage of `range` in favor of iteration over changelog Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	1130 for r in getset(repo, list(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1131 ps.update(cl.parentrevs(r))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1132 return [r for r in subset if r in ps]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1133
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1134 def parentspec(repo, subset, x, n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1135 """``set^0``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1136 The set.
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1137 ``set^1`` (or ``set^``), ``set^2``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1138 First or second parent, respectively, of all changesets in set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1139 """
12320 40c40c6f20b8 revset: handle re.compile() errors in grep() Brodie Rao <brodie@bitheap.org> parents: 11882 diff changeset	1140 try:
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1141 n = int(n[1])
14072 2e4d79dcc0a0 revset: add missing whitespace Kevin Gessner <kevin@kevingessner.com> parents: 14070 diff changeset	1142 if n not in (0, 1, 2):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1143 raise ValueError
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1144 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1145 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1146 ps = set()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1147 cl = repo.changelog
18473 692cbda1eb50 revset: evaluate sub expressions correctly (issue3775) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 18411 diff changeset	1148 for r in getset(repo, cl, x):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1149 if n == 0:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1150 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1151 elif n == 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1152 ps.add(cl.parentrevs(r)[0])
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1153 elif n == 2:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1154 parents = cl.parentrevs(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1155 if len(parents) > 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1156 ps.add(parents[1])
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1157 return [r for r in subset if r in ps]
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1158
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1159 def present(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1160 """``present(set)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1161 An empty set, if any revision in set isn't found; otherwise,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1162 all revisions in set.
16748 0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1163
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1164 If any of specified revisions is not present in the local repository,
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1165 the query is normally aborted. But this predicate allows the query
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1166 to continue even in such cases.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1167 """
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1168 try:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1169 return getset(repo, subset, x)
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1170 except error.RepoLookupError:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1171 return []
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1172
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1173 def public(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1174 """``public()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1175 Changeset in public phase."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1176 # i18n: "public" is a keyword
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1177 getargs(x, 0, 0, _("public takes no arguments"))
16657 b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	1178 pc = repo._phasecache
b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	1179 return [r for r in subset if pc.phase(repo, r) == phases.public]
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1180
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1181 def remote(repo, subset, x):
16007 f06c53ca59a9 revset: fix documentation for 'remote()' predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16006 diff changeset	1182 """``remote([id [,path]])``
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1183 Local revision that corresponds to the given identifier in a
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1184 remote repository, if present. Here, the '.' identifier is a
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1185 synonym for the current local branch.
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1186 """
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1187
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1188 import hg # avoid start-up nasties
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1189 # i18n: "remote" is a keyword
16007 f06c53ca59a9 revset: fix documentation for 'remote()' predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16006 diff changeset	1190 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1191
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1192 q = '.'
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1193 if len(l) > 0:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1194 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1195 q = getstring(l[0], _("remote requires a string id"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1196 if q == '.':
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1197 q = repo['.'].branch()
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1198
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1199 dest = ''
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1200 if len(l) > 1:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1201 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1202 dest = getstring(l[1], _("remote requires a repository path"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1203 dest = repo.ui.expandpath(dest or 'default')
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1204 dest, branches = hg.parseurl(dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1205 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1206 if revs:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1207 revs = [repo.lookup(rev) for rev in revs]
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1208 other = hg.peer(repo, {}, dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1209 n = other.lookup(q)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1210 if n in repo:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1211 r = repo[n].rev()
16006 39e60576ac98 revset: fix 'remote()' failure when remote repo has more revs than local FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15966 diff changeset	1212 if r in subset:
39e60576ac98 revset: fix 'remote()' failure when remote repo has more revs than local FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15966 diff changeset	1213 return [r]
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1214 return []
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1215
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1216 def removes(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1217 """``removes(pattern)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1218 Changesets which remove files matching pattern.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1219 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1220 # i18n: "removes" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1221 pat = getstring(x, _("removes requires a pattern"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1222 return checkstatus(repo, subset, pat, 2)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1223
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1224 def rev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1225 """``rev(number)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1226 Revision with the given numeric identifier.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1227 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1228 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1229 l = getargs(x, 1, 1, _("rev requires one argument"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1230 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1231 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1232 l = int(getstring(l[0], _("rev requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1233 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1234 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1235 raise error.ParseError(_("rev expects a number"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1236 return [r for r in subset if r == l]
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1237
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1238 def matching(repo, subset, x):
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1239 """``matching(revision [, field])``
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1240 Changesets in which a given set of fields match the set of fields in the
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1241 selected revision or set.
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1242
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1243 To match more than one field pass the list of fields to match separated
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1244 by spaces (e.g. ``author description``).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1245
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1246 Valid fields are most regular revision fields and some special fields.
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1247
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1248 Regular revision fields are ``description``, ``author``, ``branch``,
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1249 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1250 and ``diff``.
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1251 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1252 contents of the revision. Two revisions matching their ``diff`` will
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1253 also match their ``files``.
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1254
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1255 Special fields are ``summary`` and ``metadata``:
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1256 ``summary`` matches the first line of the description.
16639 00290bd359fe revset: documentation typo "metatadata" Jesse Glick <jesse.glick@oracle.com> parents: 16528 diff changeset	1257 ``metadata`` is equivalent to matching ``description user date``
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1258 (i.e. it matches the main metadata fields).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1259
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1260 ``metadata`` is the default field which is used when no fields are
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1261 specified. You can match more than one field at a time.
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1262 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1263 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1264 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1265
17804 5a511d255301 clfilter: remove use of xrange in revset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17786 diff changeset	1266 revs = getset(repo, repo.changelog, l[0])
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1267
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1268 fieldlist = ['metadata']
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1269 if len(l) > 1:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1270 fieldlist = getstring(l[1],
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1271 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1272 _("matching requires a string "
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1273 "as its second argument")).split()
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1274
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1275 # Make sure that there are no repeated fields,
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1276 # expand the 'special' 'metadata' field type
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1277 # and check the 'files' whenever we check the 'diff'
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1278 fields = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1279 for field in fieldlist:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1280 if field == 'metadata':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1281 fields += ['user', 'description', 'date']
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1282 elif field == 'diff':
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1283 # a revision matching the diff must also match the files
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1284 # since matching the diff is very costly, make sure to
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1285 # also match the files first
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1286 fields += ['files', 'diff']
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1287 else:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1288 if field == 'author':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1289 field = 'user'
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1290 fields.append(field)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1291 fields = set(fields)
16444 432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1292 if 'summary' in fields and 'description' in fields:
432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1293 # If a revision matches its description it also matches its summary
432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1294 fields.discard('summary')
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1295
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1296 # We may want to match more than one field
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1297 # Not all fields take the same amount of time to be matched
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1298 # Sort the selected fields in order of increasing matching cost
16453 d2a865d4b963 revset: make matching() work on python 2.4 Patrick Mezard <patrick@mezard.eu> parents: 16452 diff changeset	1299 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1300 'files', 'description', 'substate', 'diff']
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1301 def fieldkeyfunc(f):
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1302 try:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1303 return fieldorder.index(f)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1304 except ValueError:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1305 # assume an unknown field is very costly
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1306 return len(fieldorder)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1307 fields = list(fields)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1308 fields.sort(key=fieldkeyfunc)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1309
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1310 # Each field will be matched with its own "getfield" function
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1311 # which will be added to the getfieldfuncs array of functions
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1312 getfieldfuncs = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1313 _funcs = {
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1314 'user': lambda r: repo[r].user(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1315 'branch': lambda r: repo[r].branch(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1316 'date': lambda r: repo[r].date(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1317 'description': lambda r: repo[r].description(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1318 'files': lambda r: repo[r].files(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1319 'parents': lambda r: repo[r].parents(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1320 'phase': lambda r: repo[r].phase(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1321 'substate': lambda r: repo[r].substate,
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1322 'summary': lambda r: repo[r].description().splitlines()[0],
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1323 'diff': lambda r: list(repo[r].diff(git=True),)
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1324 }
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1325 for info in fields:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1326 getfield = _funcs.get(info, None)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1327 if getfield is None:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1328 raise error.ParseError(
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1329 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1330 _("unexpected field name passed to matching: %s") % info)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1331 getfieldfuncs.append(getfield)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1332 # convert the getfield array of functions into a "getinfo" function
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1333 # which returns an array of field values (or a single value if there
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1334 # is only one field to match)
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1335 getinfo = lambda r: [f(r) for f in getfieldfuncs]
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1336
16640 592e0beee8b0 revset: make matching() preserve input revision order Patrick Mezard <patrick@mezard.eu> parents: 16639 diff changeset	1337 matches = set()
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1338 for rev in revs:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1339 target = getinfo(rev)
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1340 for r in subset:
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1341 match = True
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1342 for n, f in enumerate(getfieldfuncs):
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1343 if target[n] != f(r):
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1344 match = False
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1345 break
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1346 if match:
16640 592e0beee8b0 revset: make matching() preserve input revision order Patrick Mezard <patrick@mezard.eu> parents: 16639 diff changeset	1347 matches.add(r)
592e0beee8b0 revset: make matching() preserve input revision order Patrick Mezard <patrick@mezard.eu> parents: 16639 diff changeset	1348 return [r for r in subset if r in matches]
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1349
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1350 def reverse(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1351 """``reverse(set)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1352 Reverse order of set.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1353 """
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1354 l = getset(repo, subset, x)
17100 ee2370d866fc revset: ensure we are reversing a list (issue3530) Bryan O'Sullivan <bryano@fb.com> parents: 17003 diff changeset	1355 if not isinstance(l, list):
ee2370d866fc revset: ensure we are reversing a list (issue3530) Bryan O'Sullivan <bryano@fb.com> parents: 17003 diff changeset	1356 l = list(l)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1357 l.reverse()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1358 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1359
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1360 def roots(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1361 """``roots(set)``
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1362 Changesets in set with no parent changeset in set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1363 """
17804 5a511d255301 clfilter: remove use of xrange in revset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17786 diff changeset	1364 s = set(getset(repo, repo.changelog, x))
17961 b0affcb67cba revset: backed out changeset 54cedee86e51 Matt Mackall <mpm@selenic.com> parents: 17952 diff changeset	1365 subset = [r for r in subset if r in s]
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1366 cs = _children(repo, subset, s)
16395 c3fd35f88fbb revset: retrieve a bit less parents in roots() Patrick Mezard <patrick@mezard.eu> parents: 16394 diff changeset	1367 return [r for r in subset if r not in cs]
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1368
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1369 def secret(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1370 """``secret()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1371 Changeset in secret phase."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1372 # i18n: "secret" is a keyword
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1373 getargs(x, 0, 0, _("secret takes no arguments"))
16657 b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	1374 pc = repo._phasecache
b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	1375 return [r for r in subset if pc.phase(repo, r) == phases.secret]
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1376
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1377 def sort(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1378 """``sort(set[, [-]key...])``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1379 Sort set by keys. The default sort order is ascending, specify a key
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1380 as ``-key`` to sort in descending order.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1381
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1382 The keys can be:
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1383
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1384 - ``rev`` for the revision number,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1385 - ``branch`` for the branch name,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1386 - ``desc`` for the commit message (description),
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1387 - ``user`` for user name (``author`` can be used as an alias),
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1388 - ``date`` for the commit date
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1389 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1390 # i18n: "sort" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1391 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1392 keys = "rev"
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1393 if len(l) == 2:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1394 # i18n: "sort" is a keyword
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1395 keys = getstring(l[1], _("sort spec must be a string"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1396
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1397 s = l[0]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1398 keys = keys.split()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1399 l = []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1400 def invert(s):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1401 return "".join(chr(255 - ord(c)) for c in s)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1402 for r in getset(repo, subset, s):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1403 c = repo[r]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1404 e = []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1405 for k in keys:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1406 if k == 'rev':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1407 e.append(r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1408 elif k == '-rev':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1409 e.append(-r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1410 elif k == 'branch':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1411 e.append(c.branch())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1412 elif k == '-branch':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1413 e.append(invert(c.branch()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1414 elif k == 'desc':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1415 e.append(c.description())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1416 elif k == '-desc':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1417 e.append(invert(c.description()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1418 elif k in 'user author':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1419 e.append(c.user())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1420 elif k in '-user -author':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1421 e.append(invert(c.user()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1422 elif k == 'date':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1423 e.append(c.date()[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1424 elif k == '-date':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1425 e.append(-c.date()[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1426 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1427 raise error.ParseError(_("unknown sort key %r") % k)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1428 e.append(r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1429 l.append(e)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1430 l.sort()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1431 return [e[-1] for e in l]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1432
16819 5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1433 def _stringmatcher(pattern):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1434 """
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1435 accepts a string, possibly starting with 're:' or 'literal:' prefix.
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1436 returns the matcher name, pattern, and matcher function.
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1437 missing or unknown prefixes are treated as literal matches.
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1438
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1439 helper for tests:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1440 >>> def test(pattern, *tests):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1441 ... kind, pattern, matcher = _stringmatcher(pattern)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1442 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1443
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1444 exact matching (no prefix):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1445 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1446 ('literal', 'abcdefg', [False, False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1447
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1448 regex matching ('re:' prefix)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1449 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1450 ('re', 'a.+b', [False, False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1451
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1452 force exact matches ('literal:' prefix)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1453 >>> test('literal:re:foobar', 'foobar', 're:foobar')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1454 ('literal', 're:foobar', [False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1455
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1456 unknown prefixes are ignored and treated as literals
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1457 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1458 ('literal', 'foo:bar', [False, False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1459 """
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1460 if pattern.startswith('re:'):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1461 pattern = pattern[3:]
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1462 try:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1463 regex = re.compile(pattern)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1464 except re.error, e:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1465 raise error.ParseError(_('invalid regular expression: %s')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1466 % e)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1467 return 're', pattern, regex.search
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1468 elif pattern.startswith('literal:'):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1469 pattern = pattern[8:]
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1470 return 'literal', pattern, pattern.__eq__
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1471
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1472 def _substringmatcher(pattern):
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1473 kind, pattern, matcher = _stringmatcher(pattern)
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1474 if kind == 'literal':
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1475 matcher = lambda s: pattern in s
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1476 return kind, pattern, matcher
16819 5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1477
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1478 def tag(repo, subset, x):
14356 02a5bebd0dc4 revset: the name is optional for the tag predicate Martin Geisler <mg@aragost.com> parents: 14355 diff changeset	1479 """``tag([name])``
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1480 The specified tag by name, or all tagged revisions if no name is given.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1481 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1482 # i18n: "tag" is a keyword
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1483 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1484 cl = repo.changelog
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1485 if args:
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1486 pattern = getstring(args[0],
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1487 # i18n: "tag" is a keyword
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1488 _('the argument to tag must be a string'))
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1489 kind, pattern, matcher = _stringmatcher(pattern)
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1490 if kind == 'literal':
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1491 # avoid resolving all tags
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1492 tn = repo._tagscache.tags.get(pattern, None)
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1493 if tn is None:
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1494 raise util.Abort(_("tag '%s' does not exist") % pattern)
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1495 s = set([repo[tn].rev()])
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1496 else:
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1497 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1498 else:
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1499 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1500 return [r for r in subset if r in s]
a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1501
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1502 def tagged(repo, subset, x):
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1503 return tag(repo, subset, x)
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1504
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1505 def unstable(repo, subset, x):
9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1506 """``unstable()``
17291 2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	1507 Non-obsolete changesets with obsolete ancestors.
2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	1508 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1509 # i18n: "unstable" is a keyword
17258 5822345e9e46 revset: use appropriate predicate name in error messages FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17244 diff changeset	1510 getargs(x, 0, 0, _("unstable takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	1511 unstables = obsmod.getrevs(repo, 'unstable')
17469 fb72eec7efd8 obsolete: introduce caches for all meaningful sets Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17424 diff changeset	1512 return [r for r in subset if r in unstables]
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1513
9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1514
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1515 def user(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1516 """``user(string)``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1517 User name contains string. The match is case-insensitive.
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1518
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1519 If `string` starts with `re:`, the remainder of the string is treated as
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1520 a regular expression. To match a user that actually contains `re:`, use
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1521 the prefix `literal:`.
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1522 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1523 return author(repo, subset, x)
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1524
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1525 # for internal use
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1526 def _list(repo, subset, x):
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1527 s = getstring(x, "internal error")
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1528 if not s:
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1529 return []
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1530 if not isinstance(subset, set):
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1531 subset = set(subset)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1532 ls = [repo[r].rev() for r in s.split('\0')]
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1533 return [r for r in ls if r in subset]
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1534
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1535 symbols = {
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1536 "adds": adds,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1537 "all": getall,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1538 "ancestor": ancestor,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1539 "ancestors": ancestors,
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	1540 "_firstancestors": _firstancestors,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1541 "author": author,
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	1542 "bisect": bisect,
13602 54b198fe9768 revset: add a revset command to get bisect state. Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13593 diff changeset	1543 "bisected": bisected,
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1544 "bookmark": bookmark,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1545 "branch": branch,
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1546 "branchpoint": branchpoint,
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	1547 "bumped": bumped,
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	1548 "bundle": bundle,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1549 "children": children,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1550 "closed": closed,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1551 "contains": contains,
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	1552 "converted": converted,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1553 "date": date,
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	1554 "desc": desc,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1555 "descendants": descendants,
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	1556 "_firstdescendants": _firstdescendants,
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	1557 "destination": destination,
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	1558 "divergent": divergent,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1559 "draft": draft,
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	1560 "extinct": extinct,
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	1561 "extra": extra,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1562 "file": hasfile,
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	1563 "filelog": filelog,
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1564 "first": first,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1565 "follow": follow,
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	1566 "_followfirst": _followfirst,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1567 "grep": grep,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1568 "head": head,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1569 "heads": heads,
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1570 "hidden": hidden,
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1571 "id": node_,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1572 "keyword": keyword,
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1573 "last": last,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1574 "limit": limit,
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1575 "_matchfiles": _matchfiles,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1576 "max": maxrev,
14649 a6a8809c6e33 revset: update sorting of symbols Thomas Arendsen Hein <thomas@intevation.de> parents: 14556 diff changeset	1577 "merge": merge,
11708 ba65d61f3158 revset: add min function Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11650 diff changeset	1578 "min": minrev,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1579 "modifies": modifies,
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1580 "obsolete": obsolete,
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1581 "origin": origin,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1582 "outgoing": outgoing,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1583 "p1": p1,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1584 "p2": p2,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1585 "parents": parents,
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1586 "present": present,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1587 "public": public,
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1588 "remote": remote,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1589 "removes": removes,
14649 a6a8809c6e33 revset: update sorting of symbols Thomas Arendsen Hein <thomas@intevation.de> parents: 14556 diff changeset	1590 "rev": rev,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1591 "reverse": reverse,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1592 "roots": roots,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1593 "sort": sort,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1594 "secret": secret,
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1595 "matching": matching,
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1596 "tag": tag,
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1597 "tagged": tagged,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1598 "user": user,
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1599 "unstable": unstable,
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1600 "_list": _list,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1601 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1602
19721 d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1603 # symbols which can't be used for a DoS attack for any given input
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1604 # (e.g. those which accept regexes as plain strings shouldn't be included)
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1605 # functions that just return a lot of changesets (like all) don't count here
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1606 safesymbols = set([
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1607 "adds",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1608 "all",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1609 "ancestor",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1610 "ancestors",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1611 "_firstancestors",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1612 "author",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1613 "bisect",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1614 "bisected",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1615 "bookmark",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1616 "branch",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1617 "branchpoint",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1618 "bumped",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1619 "bundle",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1620 "children",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1621 "closed",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1622 "converted",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1623 "date",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1624 "desc",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1625 "descendants",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1626 "_firstdescendants",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1627 "destination",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1628 "divergent",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1629 "draft",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1630 "extinct",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1631 "extra",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1632 "file",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1633 "filelog",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1634 "first",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1635 "follow",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1636 "_followfirst",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1637 "head",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1638 "heads",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1639 "hidden",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1640 "id",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1641 "keyword",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1642 "last",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1643 "limit",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1644 "_matchfiles",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1645 "max",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1646 "merge",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1647 "min",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1648 "modifies",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1649 "obsolete",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1650 "origin",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1651 "outgoing",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1652 "p1",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1653 "p2",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1654 "parents",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1655 "present",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1656 "public",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1657 "remote",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1658 "removes",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1659 "rev",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1660 "reverse",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1661 "roots",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1662 "sort",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1663 "secret",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1664 "matching",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1665 "tag",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1666 "tagged",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1667 "user",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1668 "unstable",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1669 "_list",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1670 ])
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	1671
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1672 methods = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1673 "range": rangeset,
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	1674 "dagrange": dagrange,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1675 "string": stringset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1676 "symbol": symbolset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1677 "and": andset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1678 "or": orset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1679 "not": notset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1680 "list": listset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1681 "func": func,
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1682 "ancestor": ancestorspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1683 "parent": parentspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1684 "parentpost": p1,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1685 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1686
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1687 def optimize(x, small):
13031 3da456d0c885 code style: prefer 'is' and 'is not' tests with singletons Martin Geisler <mg@aragost.com> parents: 12936 diff changeset	1688 if x is None:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1689 return 0, x
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1690
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1691 smallbonus = 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1692 if small:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1693 smallbonus = .5
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1694
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1695 op = x[0]
11283 a6356b2695a3 revset: fix - handling in the optimizer Matt Mackall <mpm@selenic.com> parents: 11282 diff changeset	1696 if op == 'minus':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1697 return optimize(('and', x[1], ('not', x[2])), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1698 elif op == 'dagrangepre':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1699 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1700 elif op == 'dagrangepost':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1701 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1702 elif op == 'rangepre':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1703 return optimize(('range', ('string', '0'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1704 elif op == 'rangepost':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1705 return optimize(('range', x[1], ('string', 'tip')), small)
11467 6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	1706 elif op == 'negate':
6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	1707 return optimize(('string',
6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	1708 '-' + getstring(x[1], _("can't negate that"))), small)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1709 elif op in 'string symbol negate':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1710 return smallbonus, x # single revisions are small
16859 eeb464ed7275 revset: drop unreachable code Bryan O'Sullivan <bryano@fb.com> parents: 16838 diff changeset	1711 elif op == 'and':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1712 wa, ta = optimize(x[1], True)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1713 wb, tb = optimize(x[2], True)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1714 w = min(wa, wb)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1715 if wa > wb:
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1716 return w, (op, tb, ta)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1717 return w, (op, ta, tb)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1718 elif op == 'or':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1719 wa, ta = optimize(x[1], False)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1720 wb, tb = optimize(x[2], False)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1721 if wb < wa:
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1722 wb, wa = wa, wb
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1723 return max(wa, wb), (op, ta, tb)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1724 elif op == 'not':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1725 o = optimize(x[1], not small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1726 return o[0], (op, o[1])
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1727 elif op == 'parentpost':
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1728 o = optimize(x[1], small)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1729 return o[0], (op, o[1])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1730 elif op == 'group':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1731 return optimize(x[1], small)
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	1732 elif op in 'dagrange range list parent ancestorspec':
14842 805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1733 if op == 'parent':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1734 # x^:y means (x^) : y, not x ^ (:y)
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1735 post = ('parentpost', x[1])
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1736 if x[2][0] == 'dagrangepre':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1737 return optimize(('dagrange', post, x[2][1]), small)
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1738 elif x[2][0] == 'rangepre':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1739 return optimize(('range', post, x[2][1]), small)
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1740
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1741 wa, ta = optimize(x[1], small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1742 wb, tb = optimize(x[2], small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1743 return wa + wb, (op, ta, tb)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1744 elif op == 'func':
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1745 f = getstring(x[1], _("not a symbol"))
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1746 wa, ta = optimize(x[2], small)
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	1747 if f in ("author branch closed date desc file grep keyword "
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	1748 "outgoing user"):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1749 w = 10 # slow
12351 b913232d13c1 revsets: reduce cost of outgoing in the optimizer Matt Mackall <mpm@selenic.com> parents: 12321 diff changeset	1750 elif f in "modifies adds removes":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1751 w = 30 # slower
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1752 elif f == "contains":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1753 w = 100 # very slow
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1754 elif f == "ancestor":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1755 w = 1 * smallbonus
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1756 elif f in "reverse limit first":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1757 w = 0
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1758 elif f in "sort":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1759 w = 10 # assume most sorts look at changelog
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1760 else:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1761 w = 1
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1762 return w + wa, (op, x[1], ta)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1763 return 1, x
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1764
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1765 _aliasarg = ('func', ('symbol', '_aliasarg'))
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1766 def _getaliasarg(tree):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1767 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1768 return X, None otherwise.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1769 """
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1770 if (len(tree) == 3 and tree[:2] == _aliasarg
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1771 and tree[2][0] == 'string'):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1772 return tree[2][1]
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1773 return None
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1774
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1775 def _checkaliasarg(tree, known=None):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1776 """Check tree contains no _aliasarg construct or only ones which
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1777 value is in known. Used to avoid alias placeholders injection.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1778 """
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1779 if isinstance(tree, tuple):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1780 arg = _getaliasarg(tree)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1781 if arg is not None and (not known or arg not in known):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1782 raise error.ParseError(_("not a function: %s") % '_aliasarg')
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1783 for t in tree:
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1784 _checkaliasarg(t, known)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1785
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1786 class revsetalias(object):
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1787 funcre = re.compile('^([^(]+)$([^)]+)$$')
14723 b9faf94ee196 revset: fix aliases with 0 or more than 2 parameters Mads Kiilerich <mads@kiilerich.com> parents: 14717 diff changeset	1788 args = None
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1789
14723 b9faf94ee196 revset: fix aliases with 0 or more than 2 parameters Mads Kiilerich <mads@kiilerich.com> parents: 14717 diff changeset	1790 def __init__(self, name, value):
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1791 '''Aliases like:
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1792
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1793 h = heads(default)
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1794 b($1) = ancestors($1) - ancestors(default)
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1795 '''
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1796 m = self.funcre.search(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1797 if m:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1798 self.name = m.group(1)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1799 self.tree = ('func', ('symbol', m.group(1)))
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1800 self.args = [x.strip() for x in m.group(2).split(',')]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1801 for arg in self.args:
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1802 # _aliasarg() is an unknown symbol only used separate
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1803 # alias argument placeholders from regular strings.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1804 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1805 else:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1806 self.name = name
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1807 self.tree = ('symbol', name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1808
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1809 self.replacement, pos = parse(value)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1810 if pos != len(value):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1811 raise error.ParseError(_('invalid token'), pos)
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1812 # Check for placeholder injection
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1813 _checkaliasarg(self.replacement, self.args)
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1814
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1815 def _getalias(aliases, tree):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1816 """If tree looks like an unexpanded alias, return it. Return None
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1817 otherwise.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1818 """
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1819 if isinstance(tree, tuple) and tree:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1820 if tree[0] == 'symbol' and len(tree) == 2:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1821 name = tree[1]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1822 alias = aliases.get(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1823 if alias and alias.args is None and alias.tree == tree:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1824 return alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1825 if tree[0] == 'func' and len(tree) > 1:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1826 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1827 name = tree[1][1]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1828 alias = aliases.get(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1829 if alias and alias.args is not None and alias.tree == tree[:2]:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1830 return alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1831 return None
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1832
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1833 def _expandargs(tree, args):
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1834 """Replace _aliasarg instances with the substitution value of the
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1835 same name in args, recursively.
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1836 """
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1837 if not tree or not isinstance(tree, tuple):
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1838 return tree
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1839 arg = _getaliasarg(tree)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1840 if arg is not None:
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1841 return args[arg]
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1842 return tuple(_expandargs(t, args) for t in tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1843
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1844 def _expandaliases(aliases, tree, expanding, cache):
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1845 """Expand aliases in tree, recursively.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1846
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1847 'aliases' is a dictionary mapping user defined aliases to
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1848 revsetalias objects.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1849 """
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1850 if not isinstance(tree, tuple):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1851 # Do not expand raw strings
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1852 return tree
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1853 alias = _getalias(aliases, tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1854 if alias is not None:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1855 if alias in expanding:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1856 raise error.ParseError(_('infinite expansion of revset alias "%s" '
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1857 'detected') % alias.name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1858 expanding.append(alias)
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1859 if alias.name not in cache:
d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1860 cache[alias.name] = _expandaliases(aliases, alias.replacement,
d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1861 expanding, cache)
d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1862 result = cache[alias.name]
16772 30e46d7138de revset: fix infinite alias expansion detection Patrick Mezard <patrick@mezard.eu> parents: 16771 diff changeset	1863 expanding.pop()
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1864 if alias.args is not None:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1865 l = getlist(tree[2])
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1866 if len(l) != len(alias.args):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1867 raise error.ParseError(
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1868 _('invalid number of arguments: %s') % len(l))
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1869 l = [_expandaliases(aliases, a, [], cache) for a in l]
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1870 result = _expandargs(result, dict(zip(alias.args, l)))
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1871 else:
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1872 result = tuple(_expandaliases(aliases, t, expanding, cache)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1873 for t in tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1874 return result
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1875
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1876 def findaliases(ui, tree):
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1877 _checkaliasarg(tree)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1878 aliases = {}
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1879 for k, v in ui.configitems('revsetalias'):
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1880 alias = revsetalias(k, v)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1881 aliases[alias.name] = alias
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	1882 return _expandaliases(aliases, tree, [], {})
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1883
20208 61a47fd64f30 fileset, revset: do not use global parser object for thread safety Yuya Nishihara <yuya@tcha.org> parents: 19721 diff changeset	1884 def parse(spec):
61a47fd64f30 fileset, revset: do not use global parser object for thread safety Yuya Nishihara <yuya@tcha.org> parents: 19721 diff changeset	1885 p = parser.parser(tokenize, elements)
61a47fd64f30 fileset, revset: do not use global parser object for thread safety Yuya Nishihara <yuya@tcha.org> parents: 19721 diff changeset	1886 return p.parse(spec)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1887
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1888 def match(ui, spec):
11385 e5a2134c083b revset: nicer exception for empty queries Matt Mackall <mpm@selenic.com> parents: 11383 diff changeset	1889 if not spec:
e5a2134c083b revset: nicer exception for empty queries Matt Mackall <mpm@selenic.com> parents: 11383 diff changeset	1890 raise error.ParseError(_("empty query"))
14496 ffcb7e4d719f revset: report a parse error if a revset is not parsed completely (issue2654) Bernhard Leiner <bleiner@gmail.com> parents: 14356 diff changeset	1891 tree, pos = parse(spec)
ffcb7e4d719f revset: report a parse error if a revset is not parsed completely (issue2654) Bernhard Leiner <bleiner@gmail.com> parents: 14356 diff changeset	1892 if (pos != len(spec)):
14701 4b93bd041772 parsers: fix localization markup of parser errors Mads Kiilerich <mads@kiilerich.com> parents: 14650 diff changeset	1893 raise error.ParseError(_("invalid token"), pos)
14900 fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	1894 if ui:
fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	1895 tree = findaliases(ui, tree)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1896 weight, tree = optimize(tree, True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1897 def mfunc(repo, subset):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1898 return getset(repo, subset, tree)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1899 return mfunc
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1900
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1901 def formatspec(expr, *args):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1902 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1903 This is a convenience function for using revsets internally, and
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1904 escapes arguments appropriately. Aliases are intentionally ignored
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1905 so that intended expression behavior isn't accidentally subverted.
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1906
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1907 Supported arguments:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1908
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1909 %r = revset expression, parenthesized
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1910 %d = int(arg), no quoting
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1911 %s = string(arg), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1912 %b = arg.branch(), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1913 %n = hex(arg), single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1914 %% = a literal '%'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1915
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1916 Prefixing the type with 'l' specifies a parenthesized list of that type.
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1917
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	1918 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	1919 '(10 or 11):: and ((this()) or (that()))'
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1920 >>> formatspec('%d:: and not %d::', 10, 20)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1921 '10:: and not 20::'
15325 cdf1daa3b83f revset: deal with empty lists in formatspec Matt Mackall <mpm@selenic.com> parents: 15268 diff changeset	1922 >>> formatspec('%ld or %ld', [], [1])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1923 "_list('') or 1"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1924 >>> formatspec('keyword(%s)', 'foo\\xe9')
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1925 "keyword('foo\\\\xe9')"
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1926 >>> b = lambda: 'default'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1927 >>> b.branch = b
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1928 >>> formatspec('branch(%b)', b)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1929 "branch('default')"
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1930 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1931 "root(_list('a\\x00b\\x00c\\x00d'))"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1932 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1933
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1934 def quote(s):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1935 return repr(str(s))
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1936
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1937 def argtype(c, arg):
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1938 if c == 'd':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1939 return str(int(arg))
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1940 elif c == 's':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1941 return quote(arg)
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1942 elif c == 'r':
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1943 parse(arg) # make sure syntax errors are confined
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1944 return '(%s)' % arg
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1945 elif c == 'n':
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1946 return quote(node.hex(arg))
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1947 elif c == 'b':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1948 return quote(arg.branch())
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1949
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1950 def listexp(s, t):
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1951 l = len(s)
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1952 if l == 0:
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1953 return "_list('')"
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1954 elif l == 1:
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1955 return argtype(t, s[0])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1956 elif t == 'd':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1957 return "_list('%s')" % "\0".join(str(int(a)) for a in s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1958 elif t == 's':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1959 return "_list('%s')" % "\0".join(s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1960 elif t == 'n':
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1961 return "_list('%s')" % "\0".join(node.hex(a) for a in s)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1962 elif t == 'b':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1963 return "_list('%s')" % "\0".join(a.branch() for a in s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1964
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15726 diff changeset	1965 m = l // 2
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1966 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1967
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1968 ret = ''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1969 pos = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1970 arg = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1971 while pos < len(expr):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1972 c = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1973 if c == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1974 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1975 d = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1976 if d == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1977 ret += d
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	1978 elif d in 'dsnbr':
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1979 ret += argtype(d, args[arg])
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1980 arg += 1
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1981 elif d == 'l':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1982 # a list of some type
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1983 pos += 1
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1984 d = expr[pos]
15596 2555f441a32f merge with stable Matt Mackall <mpm@selenic.com> parents: 15595 diff changeset	1985 ret += listexp(list(args[arg]), d)
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1986 arg += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1987 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1988 raise util.Abort('unexpected revspec format character %s' % d)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1989 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1990 ret += c
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1991 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1992
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1993 return ret
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1994
16218 81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1995 def prettyformat(tree):
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1996 def _prettyformat(tree, level, lines):
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1997 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1998 lines.append((level, str(tree)))
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1999 else:
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2000 lines.append((level, '(%s' % tree[0]))
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2001 for s in tree[1:]:
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2002 _prettyformat(s, level + 1, lines)
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2003 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2004
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2005 lines = []
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2006 _prettyformat(tree, 0, lines)
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2007 output = '\n'.join((' '*l + s) for l, s in lines)
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2008 return output
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2009
19719 2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2010 def depth(tree):
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2011 if isinstance(tree, tuple):
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2012 return max(map(depth, tree)) + 1
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2013 else:
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2014 return 0
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2015
19720 f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2016 def funcsused(tree):
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2017 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2018 return set()
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2019 else:
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2020 funcs = set()
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2021 for s in tree[1:]:
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2022 funcs \|= funcsused(s)
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2023 if tree[0] == 'func':
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2024 funcs.add(tree[1][1])
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2025 return funcs
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2026
12823 80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	2027 # tell hggettext to extract docstrings from these functions:
80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	2028 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg

annotate mercurial/revset.py @ 20288:b61ad01c4e73