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

annotate mercurial/revset.py @ 16822:da55d8a77390

revset: add pattern matching to 'bookmarks' revset expression

author	Simon King <simon@simonking.org.uk>
date	Wed, 30 May 2012 23:13:33 +0100
parents	0946502fd3d5
children	b23bacb230c9

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
16803 107a3270a24a cleanup: use the deque type where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16778 diff changeset	8 import re, collections
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
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	11 import bookmarks as bookmarksmod
12085 6f833fc3ccab Consistently import foo as foomod when foo to avoid shadowing Martin Geisler <mg@aragost.com> parents: 11944 diff changeset	12 import match as matchmod
13593 cc4721ed7a2a help: extract items doc generation function Patrick Mezard <pmezard@gmail.com> parents: 13506 diff changeset	13 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	14 import encoding
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	15
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	16 def _revancestors(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	17 """Like revlog.ancestors(), but supports followfirst."""
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	18 cut = followfirst and 1 or None
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	19 cl = repo.changelog
16803 107a3270a24a cleanup: use the deque type where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16778 diff changeset	20 visit = collections.deque(revs)
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	21 seen = set([node.nullrev])
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	22 while visit:
16803 107a3270a24a cleanup: use the deque type where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16778 diff changeset	23 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	24 if parent not in seen:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	25 visit.append(parent)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	26 seen.add(parent)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	27 yield parent
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	28
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	29 def _revdescendants(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	30 """Like revlog.descendants() but supports followfirst."""
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	31 cut = followfirst and 1 or None
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	32 cl = repo.changelog
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	33 first = min(revs)
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	34 nullrev = node.nullrev
b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	35 if first == nullrev:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	36 # 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	37 # second one? Maybe. Do we care? Probably not.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	38 for i in cl:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	39 yield i
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	40 return
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	41
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	42 seen = set(revs)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	43 for i in xrange(first + 1, len(cl)):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	44 for x in cl.parentrevs(i)[:cut]:
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	45 if x != nullrev and x in seen:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	46 seen.add(i)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	47 yield i
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	48 break
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	49
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	50 elements = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	51 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	52 "~": (18, None, ("ancestor", 18)),
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	53 "^": (18, None, ("parent", 18), ("parentpost", 18)),
12616 e797fdf91df4 revset: lower precedence of minus infix (issue2361) Matt Mackall <mpm@selenic.com> parents: 12615 diff changeset	54 "-": (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	55 "::": (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	56 ("dagrangepost", 17)),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	57 "..": (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	58 ("dagrangepost", 17)),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	59 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	60 "not": (10, ("not", 10)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	61 "!": (10, ("not", 10)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	62 "and": (5, None, ("and", 5)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	63 "&": (5, None, ("and", 5)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	64 "or": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	65 "\|": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	66 "+": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	67 ",": (2, None, ("list", 2)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	68 ")": (0, None, None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	69 "symbol": (0, ("symbol",), None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	70 "string": (0, ("string",), None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	71 "end": (0, None, None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	72 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	73
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	74 keywords = set(['and', 'or', 'not'])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	75
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	76 def tokenize(program):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	77 pos, l = 0, len(program)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	78 while pos < l:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	79 c = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	80 if c.isspace(): # skip inter-token whitespace
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	81 pass
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	82 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	83 yield ('::', None, pos)
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	84 pos += 1 # skip ahead
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	85 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	86 yield ('..', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	87 pos += 1 # skip ahead
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	88 elif c in "():,-\|&+!~^": # handle simple operators
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	89 yield (c, None, pos)
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	90 elif (c in '"\'' or c == 'r' and
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	91 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	92 if c == 'r':
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	93 pos += 1
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	94 c = program[pos]
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	95 decode = lambda x: x
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	96 else:
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	97 decode = lambda x: x.decode('string-escape')
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	98 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	99 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	100 while pos < l: # find closing quote
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	101 d = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	102 if d == '\\': # skip over escaped characters
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	103 pos += 2
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	104 continue
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	105 if d == c:
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	106 yield ('string', decode(program[s:pos]), s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	107 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	108 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	109 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	110 raise error.ParseError(_("unterminated string"), s)
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	111 # gather up a symbol/keyword
525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	112 elif c.isalnum() or c in '._' or ord(c) > 127:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	113 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	114 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	115 while pos < l: # find end of symbol
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	116 d = program[pos]
15949 d5edbbf55a75 revset: allow slashes in symbols Matt Mackall <mpm@selenic.com> parents: 15938 diff changeset	117 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	118 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	119 if d == '.' and program[pos - 1] == '.': # special case for ..
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	120 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	121 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	122 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	123 sym = program[s:pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	124 if sym in keywords: # operator keywords
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	125 yield (sym, None, s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	126 else:
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	127 yield ('symbol', sym, s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	128 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	129 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	130 raise error.ParseError(_("syntax error"), pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	131 pos += 1
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	132 yield ('end', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	133
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	134 # helpers
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	135
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	136 def getstring(x, err):
11406 42408cd43f55 revset: fix up contains/getstring when no args passed Matt Mackall <mpm@selenic.com> parents: 11404 diff changeset	137 if x and (x[0] == 'string' or x[0] == 'symbol'):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	138 return x[1]
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	139 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	140
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	141 def getlist(x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	142 if not x:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	143 return []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	144 if x[0] == 'list':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	145 return getlist(x[1]) + [x[2]]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	146 return [x]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	147
11339 744d5b73f776 revset: improve filter argument handling Matt Mackall <mpm@selenic.com> parents: 11304 diff changeset	148 def getargs(x, min, max, err):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	149 l = getlist(x)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	150 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	151 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	152 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	153
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	154 def getset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	155 if not x:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	156 raise error.ParseError(_("missing argument"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	157 return methods[x[0]](repo, subset, *x[1:])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	158
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	159 # operator methods
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	160
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	161 def stringset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	162 x = repo[x].rev()
11282 e581f3acc338 revset: fix up tests Matt Mackall <mpm@selenic.com> parents: 11280 diff changeset	163 if x == -1 and len(subset) == len(repo):
e581f3acc338 revset: fix up tests Matt Mackall <mpm@selenic.com> parents: 11280 diff changeset	164 return [-1]
13938 e44ebd2a142a revset: optimize stringset when subset == entire repo Idan Kamara <idankk86@gmail.com> parents: 13932 diff changeset	165 if len(subset) == len(repo) or x in subset:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	166 return [x]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	167 return []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	168
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	169 def symbolset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	170 if x in symbols:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	171 raise error.ParseError(_("can't use %s here") % x)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	172 return stringset(repo, subset, x)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	173
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	174 def rangeset(repo, subset, x, y):
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	175 m = getset(repo, subset, x)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	176 if not m:
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	177 m = getset(repo, range(len(repo)), x)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	178
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	179 n = getset(repo, subset, y)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	180 if not n:
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	181 n = getset(repo, range(len(repo)), y)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	182
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	183 if not m or not n:
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	184 return []
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	185 m, n = m[0], n[-1]
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	186
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	187 if m < n:
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	188 r = range(m, n + 1)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	189 else:
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	190 r = range(m, n - 1, -1)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	191 s = set(subset)
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	192 return [x for x in r if x in s]
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	193
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	194 def andset(repo, subset, x, y):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	195 return getset(repo, getset(repo, subset, x), y)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	196
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	197 def orset(repo, subset, x, y):
13932 34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	198 xl = getset(repo, subset, x)
34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	199 s = set(xl)
34f577007ffe revsets: preserve ordering with the or operator Augie Fackler <durin42@gmail.com> parents: 13915 diff changeset	200 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	201 return xl + yl
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	202
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	203 def notset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	204 s = set(getset(repo, subset, x))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	205 return [r for r in subset if r not in s]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	206
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	207 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	208 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	209
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	210 def func(repo, subset, a, b):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	211 if a[0] == 'symbol' and a[1] in symbols:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	212 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	213 raise error.ParseError(_("not a function: %s") % a[1])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	214
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	215 # functions
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	216
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	217 def adds(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	218 """``adds(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	219 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	220 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	221 # i18n: "adds" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	222 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	223 return checkstatus(repo, subset, pat, 1)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	224
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	225 def ancestor(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	226 """``ancestor(single, single)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	227 Greatest common ancestor of the two changesets.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	228 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	229 # i18n: "ancestor" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	230 l = getargs(x, 2, 2, _("ancestor requires two arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	231 r = range(len(repo))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	232 a = getset(repo, r, l[0])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	233 b = getset(repo, r, l[1])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	234 if len(a) != 1 or len(b) != 1:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	235 # i18n: "ancestor" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	236 raise error.ParseError(_("ancestor arguments must be single revisions"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	237 an = [repo[a[0]].ancestor(repo[b[0]]).rev()]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	238
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	239 return [r for r in an if r in subset]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	240
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	241 def _ancestors(repo, subset, x, followfirst=False):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	242 args = getset(repo, range(len(repo)), x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	243 if not args:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	244 return []
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	245 s = set(_revancestors(repo, args, followfirst)) \| set(args)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	246 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	247
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	248 def ancestors(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	249 """``ancestors(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	250 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	251 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	252 return _ancestors(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	253
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	254 def _firstancestors(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	255 # ``_firstancestors(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	256 # 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	257 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	258
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	259 def ancestorspec(repo, subset, x, n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	260 """``set~n``
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	261 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	262 in set.
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	263 """
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	264 try:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	265 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	266 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	267 raise error.ParseError(_("~ expects a number"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	268 ps = set()
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	269 cl = repo.changelog
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	270 for r in getset(repo, subset, x):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	271 for i in range(n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	272 r = cl.parentrevs(r)[0]
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	273 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	274 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	275
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	276 def author(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	277 """``author(string)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	278 Alias for ``user(string)``.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	279 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	280 # 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	281 n = encoding.lower(getstring(x, _("author requires a string")))
9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	282 return [r for r in subset if n in encoding.lower(repo[r].user())]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	283
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	284 def bisect(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	285 """``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	286 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	287
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	288 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	289 - ``goods``, ``bads`` : csets topologicaly good/bad
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	290 - ``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	291 - ``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	292 - ``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	293 - ``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	294 - ``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	295 """
15135 f19de58af225 revset.bisect: move bisect() code to hbisect.py "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15134 diff changeset	296 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	297 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	298 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	299
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	300 # Backward-compatibility
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	301 # - 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	302 def bisected(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	303 return bisect(repo, subset, x)
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	304
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	305 def bookmark(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	306 """``bookmark([name])``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	307 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	308
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	309 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	310 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	311 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	312 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	313 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	314 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	315 if args:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	316 bm = getstring(args[0],
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	317 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	318 _('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	319 kind, pattern, matcher = _stringmatcher(bm)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	320 if kind == 'literal':
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	321 bmrev = bookmarksmod.listbookmarks(repo).get(bm, None)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	322 if not bmrev:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	323 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	324 bmrev = repo[bmrev].rev()
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	325 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	326 else:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	327 matchrevs = set()
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	328 for name, bmrev in bookmarksmod.listbookmarks(repo).iteritems():
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	329 if matcher(name):
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	330 matchrevs.add(bmrev)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	331 if not matchrevs:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	332 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	333 % pattern)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	334 bmrevs = set()
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	335 for bmrev in matchrevs:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	336 bmrevs.add(repo[bmrev].rev())
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	337 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	338
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	339 bms = set([repo[r].rev()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	340 for r in bookmarksmod.listbookmarks(repo).values()])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	341 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	342
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	343 def branch(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	344 """``branch(string or set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	345 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	346 changesets.
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	347
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	348 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	349 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	350 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	351 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	352 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	353 b = getstring(x, '')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	354 except error.ParseError:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	355 # 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	356 pass
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	357 else:
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	358 kind, pattern, matcher = _stringmatcher(b)
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	359 if kind == 'literal':
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	360 # 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	361 # this name exists
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	362 if pattern in repo.branchmap():
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	363 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	364 else:
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	365 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	366
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	367 s = getset(repo, range(len(repo)), x)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	368 b = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	369 for r in s:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	370 b.add(repo[r].branch())
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	371 s = set(s)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	372 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	373
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	374 def checkstatus(repo, subset, pat, field):
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	375 m = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	376 s = []
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	377 hasset = matchmod.patkind(pat) == 'set'
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	378 fname = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	379 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	380 c = repo[r]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	381 if not m or hasset:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	382 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	383 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	384 fname = m.files()[0]
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	385 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	386 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	387 continue
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	388 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	389 for f in c.files():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	390 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	391 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	392 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	393 continue
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	394 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	395 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	396 if fname in files:
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	397 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	398 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	399 for f in files:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	400 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	401 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	402 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	403 return s
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	404
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	405 def _children(repo, narrow, parentset):
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	406 cs = set()
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	407 pr = repo.changelog.parentrevs
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	408 for r in narrow:
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	409 for p in pr(r):
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	410 if p in parentset:
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	411 cs.add(r)
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	412 return cs
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	413
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	414 def children(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	415 """``children(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	416 Child changesets of changesets in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	417 """
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	418 s = set(getset(repo, range(len(repo)), x))
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	419 cs = _children(repo, subset, s)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	420 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	421
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	422 def closed(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	423 """``closed()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	424 Changeset is closed.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	425 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	426 # i18n: "closed" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	427 getargs(x, 0, 0, _("closed takes no arguments"))
16720 e825a89de5d7 context: add changectx.closesbranch() method Brodie Rao <brodie@sf.io> parents: 16683 diff changeset	428 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	429
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	430 def contains(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	431 """``contains(pattern)``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	432 Revision contains a file matching pattern. See :hg:`help patterns`
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	433 for information about file patterns.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	434 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	435 # i18n: "contains" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	436 pat = getstring(x, _("contains requires a pattern"))
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	437 m = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	438 s = []
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	439 if not matchmod.patkind(pat):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	440 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	441 if pat in repo[r]:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	442 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	443 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	444 for r in subset:
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	445 c = repo[r]
6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	446 if not m or matchmod.patkind(pat) == 'set':
6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	447 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	448 for f in c.manifest():
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	449 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	450 s.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	451 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	452 return s
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	453
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	454 def date(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	455 """``date(interval)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	456 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	457 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	458 # i18n: "date" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	459 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	460 dm = util.matchdate(ds)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	461 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	462
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	463 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	464 """``desc(string)``
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	465 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	466 """
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	467 # 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	468 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	469 l = []
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	470 for r in subset:
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	471 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	472 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	473 l.append(r)
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	474 return l
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	475
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	476 def _descendants(repo, subset, x, followfirst=False):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	477 args = getset(repo, range(len(repo)), x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	478 if not args:
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	479 return []
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	480 s = set(_revdescendants(repo, args, followfirst)) \| set(args)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	481 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	482
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	483 def descendants(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	484 """``descendants(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	485 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	486 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	487 return _descendants(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	488
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	489 def _firstdescendants(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	490 # ``_firstdescendants(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	491 # 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	492 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	493
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	494 def draft(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	495 """``draft()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	496 Changeset in draft phase."""
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	497 getargs(x, 0, 0, _("draft takes no arguments"))
16657 b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	498 pc = repo._phasecache
b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	499 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	500
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	501 def extra(repo, subset, x):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	502 """``extra(label, [value])``
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	503 Changesets with the given label in the extra metadata, with the given
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	504 optional value."""
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	505
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	506 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	507 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	508 value = None
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	509
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	510 if len(l) > 1:
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	511 value = getstring(l[1], _('second 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	512
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	513 def _matchvalue(r):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	514 extra = repo[r].extra()
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	515 return label in extra and (value is None or value == extra[label])
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	516
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	517 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	518
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	519 def filelog(repo, subset, x):
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	520 """``filelog(pattern)``
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	521 Changesets connected to the specified filelog.
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	522 """
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	523
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	524 pat = getstring(x, _("filelog requires a pattern"))
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	525 m = matchmod.match(repo.root, repo.getcwd(), [pat], default='relpath',
6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	526 ctx=repo[None])
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	527 s = set()
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	528
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	529 if not matchmod.patkind(pat):
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	530 for f in m.files():
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	531 fl = repo.file(f)
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	532 for fr in fl:
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	533 s.add(fl.linkrev(fr))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	534 else:
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	535 for f in repo[None]:
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	536 if m(f):
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	537 fl = repo.file(f)
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	538 for fr in fl:
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	539 s.add(fl.linkrev(fr))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	540
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	541 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	542
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	543 def first(repo, subset, x):
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	544 """``first(set, [n])``
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	545 An alias for limit().
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	546 """
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	547 return limit(repo, subset, x)
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	548
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	549 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	550 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	551 c = repo['.']
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	552 if l:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	553 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	554 if x in c:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	555 cx = c[x]
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	556 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	557 # 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	558 s.add(cx.linkrev())
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	559 else:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	560 return []
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	561 else:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	562 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	563
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	564 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	565
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	566 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	567 """``follow([file])``
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	568 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	569 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	570 including copies.
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	571 """
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	572 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	573
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	574 def _followfirst(repo, subset, x):
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	575 # ``followfirst([file])``
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	576 # Like ``follow([file])`` but follows only the first parent of
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	577 # every revision or file revision.
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	578 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	579
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	580 def getall(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	581 """``all()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	582 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	583 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	584 # i18n: "all" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	585 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	586 return subset
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	587
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	588 def grep(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	589 """``grep(regex)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	590 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	591 to ensure special escape characters are handled correctly. Unlike
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	592 ``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	593 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	594 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	595 # i18n: "grep" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	596 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	597 except re.error, e:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	598 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	599 l = []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	600 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	601 c = repo[r]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	602 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	603 if gr.search(e):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	604 l.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	605 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	606 return l
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	607
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	608 def _matchfiles(repo, subset, x):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	609 # _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	610 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	611 # [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	612 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	613 # 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	614 # 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	615 # 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	616 # 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	617 # 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	618 # 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	619 # 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	620
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	621 # i18n: "_matchfiles" is a keyword
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	622 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	623 pats, inc, exc = [], [], []
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	624 hasset = False
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	625 rev, default = None, None
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	626 for arg in l:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	627 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	628 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	629 if prefix == 'p:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	630 pats.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	631 elif prefix == 'i:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	632 inc.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	633 elif prefix == 'x:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	634 exc.append(value)
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	635 elif prefix == 'r:':
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	636 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	637 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	638 'revision'))
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	639 rev = value
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	640 elif prefix == 'd:':
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	641 if default is not None:
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	642 raise error.ParseError(_('_matchfiles expected at most one '
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	643 'default mode'))
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	644 default = value
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	645 else:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	646 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	647 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	648 hasset = True
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	649 if not default:
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	650 default = 'glob'
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	651 m = None
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	652 s = []
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	653 for r in subset:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	654 c = repo[r]
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	655 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	656 ctx = c
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	657 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	658 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	659 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	660 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	661 for f in c.files():
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	662 if m(f):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	663 s.append(r)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	664 break
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	665 return s
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	666
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	667 def hasfile(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	668 """``file(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	669 Changesets affecting files matched by pattern.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	670 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	671 # i18n: "file" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	672 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	673 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	674
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	675 def head(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	676 """``head()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	677 Changeset is a named branch head.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	678 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	679 # i18n: "head" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	680 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	681 hs = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	682 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	683 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	684 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	685
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	686 def heads(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	687 """``heads(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	688 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	689 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	690 s = getset(repo, subset, x)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	691 ps = set(parents(repo, subset, x))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	692 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	693
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	694 def keyword(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	695 """``keyword(string)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	696 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	697 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	698 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	699 # 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	700 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	701 l = []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	702 for r in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	703 c = repo[r]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	704 t = " ".join(c.files() + [c.user(), c.description()])
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	705 if kw in encoding.lower(t):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	706 l.append(r)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	707 return l
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	708
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	709 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	710 """``limit(set, [n])``
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	711 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	712 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	713 # 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	714 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	715 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	716 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	717 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	718 # 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	719 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	720 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	721 # i18n: "limit" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	722 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	723 ss = set(subset)
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	724 os = getset(repo, range(len(repo)), l[0])[:lim]
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	725 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	726
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	727 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	728 """``last(set, [n])``
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	729 Last n members of set, defaulting to 1.
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	730 """
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	731 # 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	732 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	733 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	734 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	735 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	736 # 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	737 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	738 except (TypeError, ValueError):
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	739 # i18n: "last" is a keyword
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	740 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	741 ss = set(subset)
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	742 os = getset(repo, range(len(repo)), l[0])[-lim:]
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	743 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	744
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	745 def maxrev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	746 """``max(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	747 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	748 """
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	749 os = getset(repo, range(len(repo)), x)
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	750 if os:
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	751 m = max(os)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	752 if m in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	753 return [m]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	754 return []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	755
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	756 def merge(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	757 """``merge()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	758 Changeset is a merge changeset.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	759 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	760 # i18n: "merge" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	761 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	762 cl = repo.changelog
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	763 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	764
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	765 def minrev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	766 """``min(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	767 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	768 """
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	769 os = getset(repo, range(len(repo)), x)
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	770 if os:
f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	771 m = min(os)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	772 if m in subset:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	773 return [m]
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	774 return []
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	775
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	776 def modifies(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	777 """``modifies(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	778 Changesets modifying files matched by pattern.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	779 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	780 # i18n: "modifies" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	781 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	782 return checkstatus(repo, subset, pat, 0)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	783
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	784 def node_(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	785 """``id(string)``
12859 76066903ae08 revset: fix missing dot in docstring Wagner Bruna <wbruna@yahoo.com> parents: 12855 diff changeset	786 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	787 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	788 # 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	789 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	790 # 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	791 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	792 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	793 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	794 else:
16735 47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	795 rn = None
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	796 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	797 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	798 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	799
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	800 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	801
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	802 def outgoing(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	803 """``outgoing([path])``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	804 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	805 default push location.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	806 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	807 import hg # avoid start-up nasties
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	808 # 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	809 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	810 # i18n: "outgoing" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	811 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	812 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	813 dest, branches = hg.parseurl(dest)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	814 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	815 if revs:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	816 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	817 other = hg.peer(repo, {}, dest)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	818 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	819 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	820 repo.ui.popbuffer()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	821 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	822 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	823 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	824
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	825 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	826 """``p1([set])``
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	827 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	828 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	829 if x is None:
13878 a8d13ee0ce68 misc: replace .parents()[0] with p1() Matt Mackall <mpm@selenic.com> parents: 13873 diff changeset	830 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	831 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	832
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	833 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	834 cl = repo.changelog
12786 9aae04f4fcf6 revset: disable subset optimization for parents() and children() (issue2437) Wagner Bruna <wbruna@yahoo.com> parents: 12736 diff changeset	835 for r in getset(repo, range(len(repo)), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	836 ps.add(cl.parentrevs(r)[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	837 return [r for r in subset if r in ps]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	838
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	839 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	840 """``p2([set])``
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	841 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	842 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	843 if x is None:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	844 ps = repo[x].parents()
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	845 try:
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	846 p = ps[1].rev()
98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	847 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	848 except IndexError:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	849 return []
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	850
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	851 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	852 cl = repo.changelog
12786 9aae04f4fcf6 revset: disable subset optimization for parents() and children() (issue2437) Wagner Bruna <wbruna@yahoo.com> parents: 12736 diff changeset	853 for r in getset(repo, range(len(repo)), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	854 ps.add(cl.parentrevs(r)[1])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	855 return [r for r in subset if r in ps]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	856
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	857 def parents(repo, subset, x):
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	858 """``parents([set])``
515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	859 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	860 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	861 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	862 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	863 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	864
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	865 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	866 cl = repo.changelog
12786 9aae04f4fcf6 revset: disable subset optimization for parents() and children() (issue2437) Wagner Bruna <wbruna@yahoo.com> parents: 12736 diff changeset	867 for r in getset(repo, range(len(repo)), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	868 ps.update(cl.parentrevs(r))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	869 return [r for r in subset if r in ps]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	870
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	871 def parentspec(repo, subset, x, n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	872 """``set^0``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	873 The set.
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	874 ``set^1`` (or ``set^``), ``set^2``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	875 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	876 """
12320 40c40c6f20b8 revset: handle re.compile() errors in grep() Brodie Rao <brodie@bitheap.org> parents: 11882 diff changeset	877 try:
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	878 n = int(n[1])
14072 2e4d79dcc0a0 revset: add missing whitespace Kevin Gessner <kevin@kevingessner.com> parents: 14070 diff changeset	879 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	880 raise ValueError
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	881 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	882 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	883 ps = set()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	884 cl = repo.changelog
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	885 for r in getset(repo, subset, x):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	886 if n == 0:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	887 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	888 elif n == 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	889 ps.add(cl.parentrevs(r)[0])
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	890 elif n == 2:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	891 parents = cl.parentrevs(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	892 if len(parents) > 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	893 ps.add(parents[1])
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	894 return [r for r in subset if r in ps]
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	895
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	896 def present(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	897 """``present(set)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	898 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	899 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	900
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	901 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	902 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	903 to continue even in such cases.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	904 """
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	905 try:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	906 return getset(repo, subset, x)
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	907 except error.RepoLookupError:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	908 return []
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	909
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	910 def public(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	911 """``public()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	912 Changeset in public phase."""
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	913 getargs(x, 0, 0, _("public takes no arguments"))
16657 b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	914 pc = repo._phasecache
b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	915 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	916
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	917 def remote(repo, subset, x):
16007 f06c53ca59a9 revset: fix documentation for 'remote()' predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16006 diff changeset	918 """``remote([id [,path]])``
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	919 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	920 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	921 synonym for the current local branch.
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	922 """
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	923
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	924 import hg # avoid start-up nasties
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	925 # i18n: "remote" is a keyword
16007 f06c53ca59a9 revset: fix documentation for 'remote()' predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16006 diff changeset	926 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	927
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	928 q = '.'
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	929 if len(l) > 0:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	930 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	931 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	932 if q == '.':
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	933 q = repo['.'].branch()
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	934
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	935 dest = ''
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	936 if len(l) > 1:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	937 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	938 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	939 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	940 dest, branches = hg.parseurl(dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	941 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	942 if revs:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	943 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	944 other = hg.peer(repo, {}, dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	945 n = other.lookup(q)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	946 if n in repo:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	947 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	948 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	949 return [r]
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	950 return []
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	951
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	952 def removes(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	953 """``removes(pattern)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	954 Changesets which remove files matching pattern.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	955 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	956 # 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	957 pat = getstring(x, _("removes requires a pattern"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	958 return checkstatus(repo, subset, pat, 2)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	959
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	960 def rev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	961 """``rev(number)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	962 Revision with the given numeric identifier.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	963 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	964 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	965 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	966 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	967 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	968 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	969 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	970 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	971 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	972 return [r for r in subset if r == l]
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	973
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	974 def matching(repo, subset, x):
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	975 """``matching(revision [, field])``
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	976 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	977 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	978
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	979 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	980 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	981
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	982 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	983
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	984 Regular revision fields are ``description``, ``author``, ``branch``,
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	985 ``date``, ``files``, ``phase``, ``parents``, ``substate`` and ``user``.
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	986 Note that ``author`` and ``user`` are synonyms.
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	987
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	988 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	989 ``summary`` matches the first line of the description.
16639 00290bd359fe revset: documentation typo "metatadata" Jesse Glick <jesse.glick@oracle.com> parents: 16528 diff changeset	990 ``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	991 (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	992
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	993 ``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	994 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	995 """
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	996 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	997
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	998 revs = getset(repo, xrange(len(repo)), l[0])
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	999
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1000 fieldlist = ['metadata']
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1001 if len(l) > 1:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1002 fieldlist = getstring(l[1],
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1003 _("matching requires a string "
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1004 "as its second argument")).split()
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1005
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1006 # Make sure that there are no repeated fields, and expand the
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1007 # 'special' 'metadata' field type
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1008 fields = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1009 for field in fieldlist:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1010 if field == 'metadata':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1011 fields += ['user', 'description', 'date']
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1012 else:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1013 if field == 'author':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1014 field = 'user'
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1015 fields.append(field)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1016 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	1017 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	1018 # 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	1019 fields.discard('summary')
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1020
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1021 # 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	1022 # 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	1023 # 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	1024 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
d2a865d4b963 revset: make matching() work on python 2.4 Patrick Mezard <patrick@mezard.eu> parents: 16452 diff changeset	1025 'files', 'description', 'substate']
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1026 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	1027 try:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1028 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	1029 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	1030 # 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	1031 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	1032 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	1033 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	1034
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1035 # 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	1036 # 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	1037 getfieldfuncs = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1038 _funcs = {
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1039 'user': lambda r: repo[r].user(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1040 'branch': lambda r: repo[r].branch(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1041 'date': lambda r: repo[r].date(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1042 'description': lambda r: repo[r].description(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1043 'files': lambda r: repo[r].files(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1044 'parents': lambda r: repo[r].parents(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1045 'phase': lambda r: repo[r].phase(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1046 'substate': lambda r: repo[r].substate,
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1047 'summary': lambda r: repo[r].description().splitlines()[0],
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1048 }
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1049 for info in fields:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1050 getfield = _funcs.get(info, None)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1051 if getfield is None:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1052 raise error.ParseError(
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1053 _("unexpected field name passed to matching: %s") % info)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1054 getfieldfuncs.append(getfield)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1055 # 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	1056 # 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	1057 # 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	1058 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	1059
16640 592e0beee8b0 revset: make matching() preserve input revision order Patrick Mezard <patrick@mezard.eu> parents: 16639 diff changeset	1060 matches = set()
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1061 for rev in revs:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1062 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	1063 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	1064 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	1065 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	1066 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	1067 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	1068 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	1069 if match:
16640 592e0beee8b0 revset: make matching() preserve input revision order Patrick Mezard <patrick@mezard.eu> parents: 16639 diff changeset	1070 matches.add(r)
592e0beee8b0 revset: make matching() preserve input revision order Patrick Mezard <patrick@mezard.eu> parents: 16639 diff changeset	1071 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	1072
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1073 def reverse(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1074 """``reverse(set)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1075 Reverse order of set.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1076 """
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1077 l = getset(repo, subset, x)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1078 l.reverse()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1079 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1080
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1081 def roots(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1082 """``roots(set)``
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1083 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	1084 """
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1085 s = set(getset(repo, xrange(len(repo)), x))
16395 c3fd35f88fbb revset: retrieve a bit less parents in roots() Patrick Mezard <patrick@mezard.eu> parents: 16394 diff changeset	1086 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	1087 cs = _children(repo, subset, s)
16395 c3fd35f88fbb revset: retrieve a bit less parents in roots() Patrick Mezard <patrick@mezard.eu> parents: 16394 diff changeset	1088 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	1089
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1090 def secret(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1091 """``secret()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1092 Changeset in secret phase."""
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1093 getargs(x, 0, 0, _("secret takes no arguments"))
16657 b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	1094 pc = repo._phasecache
b6081c2c4647 phases: introduce phasecache Patrick Mezard <patrick@mezard.eu> parents: 16647 diff changeset	1095 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	1096
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1097 def sort(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1098 """``sort(set[, [-]key...])``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1099 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	1100 as ``-key`` to sort in descending order.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1101
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1102 The keys can be:
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1103
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1104 - ``rev`` for the revision number,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1105 - ``branch`` for the branch name,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1106 - ``desc`` for the commit message (description),
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1107 - ``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	1108 - ``date`` for the commit date
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1109 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1110 # 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	1111 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	1112 keys = "rev"
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1113 if len(l) == 2:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1114 keys = getstring(l[1], _("sort spec must be a string"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1115
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1116 s = l[0]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1117 keys = keys.split()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1118 l = []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1119 def invert(s):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1120 return "".join(chr(255 - ord(c)) for c in s)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1121 for r in getset(repo, subset, s):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1122 c = repo[r]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1123 e = []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1124 for k in keys:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1125 if k == 'rev':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1126 e.append(r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1127 elif k == '-rev':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1128 e.append(-r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1129 elif k == 'branch':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1130 e.append(c.branch())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1131 elif k == '-branch':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1132 e.append(invert(c.branch()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1133 elif k == 'desc':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1134 e.append(c.description())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1135 elif k == '-desc':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1136 e.append(invert(c.description()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1137 elif k in 'user author':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1138 e.append(c.user())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1139 elif k in '-user -author':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1140 e.append(invert(c.user()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1141 elif k == 'date':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1142 e.append(c.date()[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1143 elif k == '-date':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1144 e.append(-c.date()[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1145 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1146 raise error.ParseError(_("unknown sort key %r") % k)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1147 e.append(r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1148 l.append(e)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1149 l.sort()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1150 return [e[-1] for e in l]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1151
16819 5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1152 def _stringmatcher(pattern):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1153 """
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1154 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	1155 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	1156 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	1157
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1158 helper for tests:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1159 >>> def test(pattern, *tests):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1160 ... 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	1161 ... 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	1162
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1163 exact matching (no prefix):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1164 >>> 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	1165 ('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	1166
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1167 regex matching ('re:' prefix)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1168 >>> 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	1169 ('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	1170
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1171 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	1172 >>> 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	1173 ('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	1174
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1175 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	1176 >>> 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	1177 ('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	1178 """
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1179 if pattern.startswith('re:'):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1180 pattern = pattern[3:]
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1181 try:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1182 regex = re.compile(pattern)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1183 except re.error, e:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1184 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	1185 % e)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1186 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	1187 elif pattern.startswith('literal:'):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1188 pattern = pattern[8:]
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1189 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	1190
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1191
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	1192 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	1193 """``tag([name])``
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1194 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	1195 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1196 # 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	1197 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	1198 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	1199 if args:
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1200 pattern = getstring(args[0],
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1201 # i18n: "tag" is a keyword
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1202 _('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	1203 kind, pattern, matcher = _stringmatcher(pattern)
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1204 if kind == 'literal':
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1205 if not repo.tags().get(pattern, None):
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1206 raise util.Abort(_("tag '%s' does not exist") % pattern)
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1207 s = set([cl.rev(n) for t, n in repo.tagslist() if t == pattern])
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1208 else:
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1209 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1210 if not s:
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1211 raise util.Abort(_("no tags exist that match '%s'") % pattern)
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	1212 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	1213 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	1214 return [r for r in subset if r in s]
a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1215
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1216 def tagged(repo, subset, x):
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1217 return tag(repo, subset, x)
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1218
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1219 def user(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1220 """``user(string)``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1221 User name contains string. The match is case-insensitive.
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1222 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1223 return author(repo, subset, x)
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1224
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1225 # for internal use
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1226 def _list(repo, subset, x):
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1227 s = getstring(x, "internal error")
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1228 if not s:
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1229 return []
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1230 if not isinstance(subset, set):
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1231 subset = set(subset)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1232 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	1233 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	1234
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1235 symbols = {
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1236 "adds": adds,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1237 "all": getall,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1238 "ancestor": ancestor,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1239 "ancestors": ancestors,
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	1240 "_firstancestors": _firstancestors,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1241 "author": author,
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	1242 "bisect": bisect,
13602 54b198fe9768 revset: add a revset command to get bisect state. Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13593 diff changeset	1243 "bisected": bisected,
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1244 "bookmark": bookmark,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1245 "branch": branch,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1246 "children": children,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1247 "closed": closed,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1248 "contains": contains,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1249 "date": date,
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	1250 "desc": desc,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1251 "descendants": descendants,
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	1252 "_firstdescendants": _firstdescendants,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1253 "draft": draft,
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	1254 "extra": extra,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1255 "file": hasfile,
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	1256 "filelog": filelog,
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1257 "first": first,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1258 "follow": follow,
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	1259 "_followfirst": _followfirst,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1260 "grep": grep,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1261 "head": head,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1262 "heads": heads,
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1263 "id": node_,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1264 "keyword": keyword,
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1265 "last": last,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1266 "limit": limit,
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1267 "_matchfiles": _matchfiles,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1268 "max": maxrev,
14649 a6a8809c6e33 revset: update sorting of symbols Thomas Arendsen Hein <thomas@intevation.de> parents: 14556 diff changeset	1269 "merge": merge,
11708 ba65d61f3158 revset: add min function Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11650 diff changeset	1270 "min": minrev,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1271 "modifies": modifies,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1272 "outgoing": outgoing,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1273 "p1": p1,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1274 "p2": p2,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1275 "parents": parents,
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1276 "present": present,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1277 "public": public,
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1278 "remote": remote,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1279 "removes": removes,
14649 a6a8809c6e33 revset: update sorting of symbols Thomas Arendsen Hein <thomas@intevation.de> parents: 14556 diff changeset	1280 "rev": rev,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1281 "reverse": reverse,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1282 "roots": roots,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	1283 "sort": sort,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1284 "secret": secret,
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1285 "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	1286 "tag": tag,
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1287 "tagged": tagged,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1288 "user": user,
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1289 "_list": _list,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1290 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1291
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1292 methods = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1293 "range": rangeset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1294 "string": stringset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1295 "symbol": symbolset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1296 "and": andset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1297 "or": orset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1298 "not": notset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1299 "list": listset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1300 "func": func,
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1301 "ancestor": ancestorspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1302 "parent": parentspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1303 "parentpost": p1,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1304 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1305
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1306 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	1307 if x is None:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1308 return 0, x
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1309
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1310 smallbonus = 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1311 if small:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1312 smallbonus = .5
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1313
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1314 op = x[0]
11283 a6356b2695a3 revset: fix - handling in the optimizer Matt Mackall <mpm@selenic.com> parents: 11282 diff changeset	1315 if op == 'minus':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1316 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	1317 elif op == 'dagrange':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1318 return optimize(('and', ('func', ('symbol', 'descendants'), x[1]),
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1319 ('func', ('symbol', 'ancestors'), x[2])), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1320 elif op == 'dagrangepre':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1321 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1322 elif op == 'dagrangepost':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1323 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1324 elif op == 'rangepre':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1325 return optimize(('range', ('string', '0'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1326 elif op == 'rangepost':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1327 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	1328 elif op == 'negate':
6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	1329 return optimize(('string',
6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	1330 '-' + 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	1331 elif op in 'string symbol negate':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1332 return smallbonus, x # single revisions are small
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1333 elif op == 'and' or op == 'dagrange':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1334 wa, ta = optimize(x[1], True)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1335 wb, tb = optimize(x[2], True)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1336 w = min(wa, wb)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1337 if wa > wb:
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1338 return w, (op, tb, ta)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1339 return w, (op, ta, tb)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1340 elif op == 'or':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1341 wa, ta = optimize(x[1], False)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1342 wb, tb = optimize(x[2], False)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1343 if wb < wa:
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1344 wb, wa = wa, wb
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1345 return max(wa, wb), (op, ta, tb)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1346 elif op == 'not':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1347 o = optimize(x[1], not small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1348 return o[0], (op, o[1])
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1349 elif op == 'parentpost':
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1350 o = optimize(x[1], small)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1351 return o[0], (op, o[1])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1352 elif op == 'group':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1353 return optimize(x[1], small)
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1354 elif op in 'range list parent ancestorspec':
14842 805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1355 if op == 'parent':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1356 # 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	1357 post = ('parentpost', x[1])
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1358 if x[2][0] == 'dagrangepre':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1359 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	1360 elif x[2][0] == 'rangepre':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	1361 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	1362
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1363 wa, ta = optimize(x[1], small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1364 wb, tb = optimize(x[2], small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1365 return wa + wb, (op, ta, tb)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1366 elif op == 'func':
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1367 f = getstring(x[1], _("not a symbol"))
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1368 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	1369 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	1370 "outgoing user"):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1371 w = 10 # slow
12351 b913232d13c1 revsets: reduce cost of outgoing in the optimizer Matt Mackall <mpm@selenic.com> parents: 12321 diff changeset	1372 elif f in "modifies adds removes":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1373 w = 30 # slower
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1374 elif f == "contains":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1375 w = 100 # very slow
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1376 elif f == "ancestor":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1377 w = 1 * smallbonus
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1378 elif f in "reverse limit first":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1379 w = 0
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1380 elif f in "sort":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1381 w = 10 # assume most sorts look at changelog
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1382 else:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1383 w = 1
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1384 return w + wa, (op, x[1], ta)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1385 return 1, x
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1386
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1387 _aliasarg = ('func', ('symbol', '_aliasarg'))
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1388 def _getaliasarg(tree):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1389 """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	1390 return X, None otherwise.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1391 """
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1392 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	1393 and tree[2][0] == 'string'):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1394 return tree[2][1]
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1395 return None
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1396
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1397 def _checkaliasarg(tree, known=None):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1398 """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	1399 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	1400 """
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1401 if isinstance(tree, tuple):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1402 arg = _getaliasarg(tree)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1403 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	1404 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	1405 for t in tree:
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1406 _checkaliasarg(t, known)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1407
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1408 class revsetalias(object):
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1409 funcre = re.compile('^([^(]+)$([^)]+)$$')
14723 b9faf94ee196 revset: fix aliases with 0 or more than 2 parameters Mads Kiilerich <mads@kiilerich.com> parents: 14717 diff changeset	1410 args = None
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1411
14723 b9faf94ee196 revset: fix aliases with 0 or more than 2 parameters Mads Kiilerich <mads@kiilerich.com> parents: 14717 diff changeset	1412 def __init__(self, name, value):
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1413 '''Aliases like:
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1414
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1415 h = heads(default)
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1416 b($1) = ancestors($1) - ancestors(default)
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1417 '''
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1418 m = self.funcre.search(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1419 if m:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1420 self.name = m.group(1)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1421 self.tree = ('func', ('symbol', m.group(1)))
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1422 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	1423 for arg in self.args:
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1424 # _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	1425 # alias argument placeholders from regular strings.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1426 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1427 else:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1428 self.name = name
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1429 self.tree = ('symbol', name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1430
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1431 self.replacement, pos = parse(value)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1432 if pos != len(value):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1433 raise error.ParseError(_('invalid token'), pos)
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1434 # Check for placeholder injection
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1435 _checkaliasarg(self.replacement, self.args)
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1436
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1437 def _getalias(aliases, tree):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1438 """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	1439 otherwise.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1440 """
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1441 if isinstance(tree, tuple) and tree:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1442 if tree[0] == 'symbol' and len(tree) == 2:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1443 name = tree[1]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1444 alias = aliases.get(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1445 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	1446 return alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1447 if tree[0] == 'func' and len(tree) > 1:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1448 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	1449 name = tree[1][1]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1450 alias = aliases.get(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1451 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	1452 return alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1453 return None
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1454
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1455 def _expandargs(tree, args):
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1456 """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	1457 same name in args, recursively.
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1458 """
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1459 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	1460 return tree
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1461 arg = _getaliasarg(tree)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1462 if arg is not None:
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1463 return args[arg]
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1464 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	1465
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1466 def _expandaliases(aliases, tree, expanding):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1467 """Expand aliases in tree, recursively.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1468
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1469 '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	1470 revsetalias objects.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1471 """
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1472 if not isinstance(tree, tuple):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1473 # Do not expand raw strings
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1474 return tree
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1475 alias = _getalias(aliases, tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1476 if alias is not None:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1477 if alias in expanding:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1478 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	1479 'detected') % alias.name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1480 expanding.append(alias)
16772 30e46d7138de revset: fix infinite alias expansion detection Patrick Mezard <patrick@mezard.eu> parents: 16771 diff changeset	1481 result = _expandaliases(aliases, alias.replacement, expanding)
30e46d7138de revset: fix infinite alias expansion detection Patrick Mezard <patrick@mezard.eu> parents: 16771 diff changeset	1482 expanding.pop()
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1483 if alias.args is not None:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1484 l = getlist(tree[2])
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1485 if len(l) != len(alias.args):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1486 raise error.ParseError(
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1487 _('invalid number of arguments: %s') % len(l))
16772 30e46d7138de revset: fix infinite alias expansion detection Patrick Mezard <patrick@mezard.eu> parents: 16771 diff changeset	1488 l = [_expandaliases(aliases, a, []) for a in l]
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1489 result = _expandargs(result, dict(zip(alias.args, l)))
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1490 else:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1491 result = tuple(_expandaliases(aliases, t, expanding)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1492 for t in tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1493 return result
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1494
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1495 def findaliases(ui, tree):
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	1496 _checkaliasarg(tree)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1497 aliases = {}
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1498 for k, v in ui.configitems('revsetalias'):
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1499 alias = revsetalias(k, v)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1500 aliases[alias.name] = alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1501 return _expandaliases(aliases, tree, [])
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1502
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1503 parse = parser.parser(tokenize, elements).parse
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1504
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	1505 def match(ui, spec):
11385 e5a2134c083b revset: nicer exception for empty queries Matt Mackall <mpm@selenic.com> parents: 11383 diff changeset	1506 if not spec:
e5a2134c083b revset: nicer exception for empty queries Matt Mackall <mpm@selenic.com> parents: 11383 diff changeset	1507 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	1508 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	1509 if (pos != len(spec)):
14701 4b93bd041772 parsers: fix localization markup of parser errors Mads Kiilerich <mads@kiilerich.com> parents: 14650 diff changeset	1510 raise error.ParseError(_("invalid token"), pos)
14900 fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	1511 if ui:
fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	1512 tree = findaliases(ui, tree)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	1513 weight, tree = optimize(tree, True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1514 def mfunc(repo, subset):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1515 return getset(repo, subset, tree)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1516 return mfunc
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1517
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1518 def formatspec(expr, *args):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1519 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1520 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	1521 escapes arguments appropriately. Aliases are intentionally ignored
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1522 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	1523
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1524 Supported arguments:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1525
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1526 %r = revset expression, parenthesized
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1527 %d = int(arg), no quoting
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1528 %s = string(arg), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1529 %b = arg.branch(), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1530 %n = hex(arg), single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1531 %% = a literal '%'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1532
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1533 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	1534
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	1535 >>> 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	1536 '(10 or 11):: and ((this()) or (that()))'
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1537 >>> formatspec('%d:: and not %d::', 10, 20)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1538 '10:: and not 20::'
15325 cdf1daa3b83f revset: deal with empty lists in formatspec Matt Mackall <mpm@selenic.com> parents: 15268 diff changeset	1539 >>> formatspec('%ld or %ld', [], [1])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1540 "_list('') or 1"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1541 >>> formatspec('keyword(%s)', 'foo\\xe9')
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1542 "keyword('foo\\\\xe9')"
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1543 >>> b = lambda: 'default'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1544 >>> b.branch = b
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1545 >>> formatspec('branch(%b)', b)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1546 "branch('default')"
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1547 >>> 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	1548 "root(_list('a\\x00b\\x00c\\x00d'))"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1549 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1550
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1551 def quote(s):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1552 return repr(str(s))
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1553
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1554 def argtype(c, arg):
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1555 if c == 'd':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1556 return str(int(arg))
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1557 elif c == 's':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1558 return quote(arg)
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1559 elif c == 'r':
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	1560 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	1561 return '(%s)' % arg
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1562 elif c == 'n':
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1563 return quote(node.hex(arg))
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1564 elif c == 'b':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1565 return quote(arg.branch())
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1566
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1567 def listexp(s, t):
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1568 l = len(s)
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1569 if l == 0:
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1570 return "_list('')"
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1571 elif l == 1:
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1572 return argtype(t, s[0])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1573 elif t == 'd':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1574 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	1575 elif t == 's':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1576 return "_list('%s')" % "\0".join(s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1577 elif t == 'n':
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1578 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	1579 elif t == 'b':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1580 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	1581
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15726 diff changeset	1582 m = l // 2
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	1583 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	1584
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1585 ret = ''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1586 pos = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1587 arg = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1588 while pos < len(expr):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1589 c = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1590 if c == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1591 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1592 d = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1593 if d == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1594 ret += d
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	1595 elif d in 'dsnbr':
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1596 ret += argtype(d, args[arg])
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1597 arg += 1
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1598 elif d == 'l':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1599 # a list of some type
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1600 pos += 1
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	1601 d = expr[pos]
15596 2555f441a32f merge with stable Matt Mackall <mpm@selenic.com> parents: 15595 diff changeset	1602 ret += listexp(list(args[arg]), d)
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1603 arg += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1604 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1605 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	1606 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1607 ret += c
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1608 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1609
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1610 return ret
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	1611
16218 81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1612 def prettyformat(tree):
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1613 def _prettyformat(tree, level, lines):
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1614 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	1615 lines.append((level, str(tree)))
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1616 else:
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1617 lines.append((level, '(%s' % tree[0]))
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1618 for s in tree[1:]:
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1619 _prettyformat(s, level + 1, lines)
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1620 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1621
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1622 lines = []
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1623 _prettyformat(tree, 0, lines)
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1624 output = '\n'.join((' '*l + s) for l, s in lines)
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1625 return output
81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	1626
12823 80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	1627 # 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	1628 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/revset.py @ 16822:da55d8a77390