revset.py
598 lines
| 17.1 KiB
| text/x-python
|
PythonLexer
/ mercurial / revset.py
|
r11275 | # revset.py - revision set queries for mercurial | ||
# | ||||
# Copyright 2010 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
import re | ||||
|
r11301 | import parser, util, error, discovery | ||
|
r12085 | import match as matchmod | ||
|
r11383 | from i18n import _ | ||
|
r11275 | |||
elements = { | ||||
"(": (20, ("group", 1, ")"), ("func", 1, ")")), | ||||
"-": (19, ("negate", 19), ("minus", 19)), | ||||
|
r11278 | "::": (17, ("dagrangepre", 17), ("dagrange", 17), | ||
("dagrangepost", 17)), | ||||
"..": (17, ("dagrangepre", 17), ("dagrange", 17), | ||||
("dagrangepost", 17)), | ||||
":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)), | ||||
|
r11275 | "not": (10, ("not", 10)), | ||
"!": (10, ("not", 10)), | ||||
"and": (5, None, ("and", 5)), | ||||
"&": (5, None, ("and", 5)), | ||||
"or": (4, None, ("or", 4)), | ||||
"|": (4, None, ("or", 4)), | ||||
"+": (4, None, ("or", 4)), | ||||
",": (2, None, ("list", 2)), | ||||
")": (0, None, None), | ||||
"symbol": (0, ("symbol",), None), | ||||
"string": (0, ("string",), None), | ||||
"end": (0, None, None), | ||||
} | ||||
keywords = set(['and', 'or', 'not']) | ||||
def tokenize(program): | ||||
pos, l = 0, len(program) | ||||
while pos < l: | ||||
c = program[pos] | ||||
if c.isspace(): # skip inter-token whitespace | ||||
pass | ||||
|
r11278 | elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully | ||
|
r11289 | yield ('::', None, pos) | ||
|
r11278 | pos += 1 # skip ahead | ||
|
r11275 | elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully | ||
|
r11289 | yield ('..', None, pos) | ||
|
r11275 | pos += 1 # skip ahead | ||
|
r11278 | elif c in "():,-|&+!": # handle simple operators | ||
|
r11289 | yield (c, None, pos) | ||
|
r12408 | elif (c in '"\'' or c == 'r' and | ||
program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings | ||||
if c == 'r': | ||||
pos += 1 | ||||
c = program[pos] | ||||
decode = lambda x: x | ||||
else: | ||||
decode = lambda x: x.decode('string-escape') | ||||
|
r11275 | pos += 1 | ||
s = pos | ||||
while pos < l: # find closing quote | ||||
d = program[pos] | ||||
if d == '\\': # skip over escaped characters | ||||
pos += 2 | ||||
continue | ||||
if d == c: | ||||
|
r12408 | yield ('string', decode(program[s:pos]), s) | ||
|
r11275 | break | ||
pos += 1 | ||||
else: | ||||
|
r11383 | raise error.ParseError(_("unterminated string"), s) | ||
|
r11404 | elif c.isalnum() or c in '._' or ord(c) > 127: # gather up a symbol/keyword | ||
|
r11275 | s = pos | ||
pos += 1 | ||||
while pos < l: # find end of symbol | ||||
d = program[pos] | ||||
|
r11404 | if not (d.isalnum() or d in "._" or ord(d) > 127): | ||
|
r11275 | break | ||
if d == '.' and program[pos - 1] == '.': # special case for .. | ||||
pos -= 1 | ||||
break | ||||
pos += 1 | ||||
sym = program[s:pos] | ||||
if sym in keywords: # operator keywords | ||||
|
r11289 | yield (sym, None, s) | ||
|
r11275 | else: | ||
|
r11289 | yield ('symbol', sym, s) | ||
|
r11275 | pos -= 1 | ||
else: | ||||
|
r11383 | raise error.ParseError(_("syntax error"), pos) | ||
|
r11275 | pos += 1 | ||
|
r11289 | yield ('end', None, pos) | ||
|
r11275 | |||
# helpers | ||||
def getstring(x, err): | ||||
|
r12401 | if x and (x[0] == 'string' or x[0] == 'symbol'): | ||
|
r11275 | return x[1] | ||
|
r11289 | raise error.ParseError(err) | ||
|
r11275 | |||
def getlist(x): | ||||
if not x: | ||||
return [] | ||||
if x[0] == 'list': | ||||
return getlist(x[1]) + [x[2]] | ||||
return [x] | ||||
|
r11339 | def getargs(x, min, max, err): | ||
|
r11275 | l = getlist(x) | ||
|
r11339 | if len(l) < min or len(l) > max: | ||
|
r11289 | raise error.ParseError(err) | ||
|
r11275 | return l | ||
def getset(repo, subset, x): | ||||
if not x: | ||||
|
r11383 | raise error.ParseError(_("missing argument")) | ||
|
r11275 | return methods[x[0]](repo, subset, *x[1:]) | ||
# operator methods | ||||
def stringset(repo, subset, x): | ||||
x = repo[x].rev() | ||||
|
r11282 | if x == -1 and len(subset) == len(repo): | ||
return [-1] | ||||
|
r11275 | if x in subset: | ||
return [x] | ||||
return [] | ||||
def symbolset(repo, subset, x): | ||||
if x in symbols: | ||||
|
r11383 | raise error.ParseError(_("can't use %s here") % x) | ||
|
r11275 | return stringset(repo, subset, x) | ||
def rangeset(repo, subset, x, y): | ||||
|
r11456 | m = getset(repo, subset, x) | ||
if not m: | ||||
m = getset(repo, range(len(repo)), x) | ||||
n = getset(repo, subset, y) | ||||
if not n: | ||||
n = getset(repo, range(len(repo)), y) | ||||
if not m or not n: | ||||
return [] | ||||
m, n = m[0], n[-1] | ||||
|
r11275 | if m < n: | ||
|
r11456 | r = range(m, n + 1) | ||
else: | ||||
r = range(m, n - 1, -1) | ||||
s = set(subset) | ||||
return [x for x in r if x in s] | ||||
|
r11275 | |||
def andset(repo, subset, x, y): | ||||
return getset(repo, getset(repo, subset, x), y) | ||||
def orset(repo, subset, x, y): | ||||
s = set(getset(repo, subset, x)) | ||||
s |= set(getset(repo, [r for r in subset if r not in s], y)) | ||||
return [r for r in subset if r in s] | ||||
def notset(repo, subset, x): | ||||
s = set(getset(repo, subset, x)) | ||||
return [r for r in subset if r not in s] | ||||
def listset(repo, subset, a, b): | ||||
|
r11383 | raise error.ParseError(_("can't use a list in this context")) | ||
|
r11275 | |||
def func(repo, subset, a, b): | ||||
if a[0] == 'symbol' and a[1] in symbols: | ||||
return symbols[a[1]](repo, subset, b) | ||||
|
r11383 | raise error.ParseError(_("not a function: %s") % a[1]) | ||
|
r11275 | |||
# functions | ||||
def p1(repo, subset, x): | ||||
ps = set() | ||||
cl = repo.changelog | ||||
for r in getset(repo, subset, x): | ||||
ps.add(cl.parentrevs(r)[0]) | ||||
return [r for r in subset if r in ps] | ||||
def p2(repo, subset, x): | ||||
ps = set() | ||||
cl = repo.changelog | ||||
for r in getset(repo, subset, x): | ||||
ps.add(cl.parentrevs(r)[1]) | ||||
return [r for r in subset if r in ps] | ||||
def parents(repo, subset, x): | ||||
ps = set() | ||||
cl = repo.changelog | ||||
for r in getset(repo, subset, x): | ||||
ps.update(cl.parentrevs(r)) | ||||
return [r for r in subset if r in ps] | ||||
def maxrev(repo, subset, x): | ||||
s = getset(repo, subset, x) | ||||
if s: | ||||
m = max(s) | ||||
if m in subset: | ||||
return [m] | ||||
return [] | ||||
|
r11708 | def minrev(repo, subset, x): | ||
s = getset(repo, subset, x) | ||||
if s: | ||||
m = min(s) | ||||
if m in subset: | ||||
return [m] | ||||
return [] | ||||
|
r11275 | def limit(repo, subset, x): | ||
|
r11383 | l = getargs(x, 2, 2, _("limit wants two arguments")) | ||
|
r11275 | try: | ||
|
r11383 | lim = int(getstring(l[1], _("limit wants a number"))) | ||
|
r11275 | except ValueError: | ||
|
r11383 | raise error.ParseError(_("limit expects a number")) | ||
|
r11275 | return getset(repo, subset, l[0])[:lim] | ||
def children(repo, subset, x): | ||||
cs = set() | ||||
cl = repo.changelog | ||||
s = set(getset(repo, subset, x)) | ||||
for r in xrange(0, len(repo)): | ||||
for p in cl.parentrevs(r): | ||||
if p in s: | ||||
cs.add(r) | ||||
return [r for r in subset if r in cs] | ||||
def branch(repo, subset, x): | ||||
s = getset(repo, range(len(repo)), x) | ||||
b = set() | ||||
for r in s: | ||||
b.add(repo[r].branch()) | ||||
s = set(s) | ||||
return [r for r in subset if r in s or repo[r].branch() in b] | ||||
def ancestor(repo, subset, x): | ||||
|
r11383 | l = getargs(x, 2, 2, _("ancestor wants two arguments")) | ||
|
r11650 | r = range(len(repo)) | ||
a = getset(repo, r, l[0]) | ||||
b = getset(repo, r, l[1]) | ||||
if len(a) != 1 or len(b) != 1: | ||||
|
r11383 | raise error.ParseError(_("ancestor arguments must be single revisions")) | ||
|
r11650 | an = [repo[a[0]].ancestor(repo[b[0]]).rev()] | ||
return [r for r in an if r in subset] | ||||
|
r11275 | |||
def ancestors(repo, subset, x): | ||||
args = getset(repo, range(len(repo)), x) | ||||
|
r11456 | if not args: | ||
return [] | ||||
|
r11275 | s = set(repo.changelog.ancestors(*args)) | set(args) | ||
return [r for r in subset if r in s] | ||||
def descendants(repo, subset, x): | ||||
args = getset(repo, range(len(repo)), x) | ||||
|
r11456 | if not args: | ||
return [] | ||||
|
r11275 | s = set(repo.changelog.descendants(*args)) | set(args) | ||
return [r for r in subset if r in s] | ||||
def follow(repo, subset, x): | ||||
|
r11383 | getargs(x, 0, 0, _("follow takes no arguments")) | ||
|
r11275 | p = repo['.'].rev() | ||
s = set(repo.changelog.ancestors(p)) | set([p]) | ||||
return [r for r in subset if r in s] | ||||
def date(repo, subset, x): | ||||
|
r11383 | ds = getstring(x, _("date wants a string")) | ||
|
r11275 | dm = util.matchdate(ds) | ||
return [r for r in subset if dm(repo[r].date()[0])] | ||||
def keyword(repo, subset, x): | ||||
|
r11383 | kw = getstring(x, _("keyword wants a string")).lower() | ||
|
r11275 | l = [] | ||
for r in subset: | ||||
c = repo[r] | ||||
t = " ".join(c.files() + [c.user(), c.description()]) | ||||
if kw in t.lower(): | ||||
l.append(r) | ||||
return l | ||||
def grep(repo, subset, x): | ||||
|
r12320 | try: | ||
gr = re.compile(getstring(x, _("grep wants a string"))) | ||||
except re.error, e: | ||||
raise error.ParseError(_('invalid match pattern: %s') % e) | ||||
|
r11275 | l = [] | ||
for r in subset: | ||||
c = repo[r] | ||||
for e in c.files() + [c.user(), c.description()]: | ||||
if gr.search(e): | ||||
l.append(r) | ||||
continue | ||||
return l | ||||
def author(repo, subset, x): | ||||
|
r11383 | n = getstring(x, _("author wants a string")).lower() | ||
|
r11275 | return [r for r in subset if n in repo[r].user().lower()] | ||
def hasfile(repo, subset, x): | ||||
|
r11383 | pat = getstring(x, _("file wants a pattern")) | ||
|
r12085 | m = matchmod.match(repo.root, repo.getcwd(), [pat]) | ||
|
r11275 | s = [] | ||
for r in subset: | ||||
for f in repo[r].files(): | ||||
if m(f): | ||||
s.append(r) | ||||
continue | ||||
return s | ||||
def contains(repo, subset, x): | ||||
|
r11406 | pat = getstring(x, _("contains wants a pattern")) | ||
|
r12085 | m = matchmod.match(repo.root, repo.getcwd(), [pat]) | ||
|
r11275 | s = [] | ||
if m.files() == [pat]: | ||||
for r in subset: | ||||
if pat in repo[r]: | ||||
s.append(r) | ||||
continue | ||||
else: | ||||
for r in subset: | ||||
for f in repo[r].manifest(): | ||||
if m(f): | ||||
s.append(r) | ||||
continue | ||||
return s | ||||
def checkstatus(repo, subset, pat, field): | ||||
|
r12085 | m = matchmod.match(repo.root, repo.getcwd(), [pat]) | ||
|
r11275 | s = [] | ||
fast = (m.files() == [pat]) | ||||
for r in subset: | ||||
c = repo[r] | ||||
if fast: | ||||
if pat not in c.files(): | ||||
continue | ||||
else: | ||||
for f in c.files(): | ||||
if m(f): | ||||
break | ||||
else: | ||||
continue | ||||
files = repo.status(c.p1().node(), c.node())[field] | ||||
if fast: | ||||
if pat in files: | ||||
s.append(r) | ||||
continue | ||||
else: | ||||
for f in files: | ||||
if m(f): | ||||
s.append(r) | ||||
continue | ||||
return s | ||||
def modifies(repo, subset, x): | ||||
|
r11383 | pat = getstring(x, _("modifies wants a pattern")) | ||
|
r11275 | return checkstatus(repo, subset, pat, 0) | ||
def adds(repo, subset, x): | ||||
|
r11383 | pat = getstring(x, _("adds wants a pattern")) | ||
|
r11275 | return checkstatus(repo, subset, pat, 1) | ||
def removes(repo, subset, x): | ||||
|
r11383 | pat = getstring(x, _("removes wants a pattern")) | ||
|
r11275 | return checkstatus(repo, subset, pat, 2) | ||
def merge(repo, subset, x): | ||||
|
r11383 | getargs(x, 0, 0, _("merge takes no arguments")) | ||
|
r11275 | cl = repo.changelog | ||
return [r for r in subset if cl.parentrevs(r)[1] != -1] | ||||
def closed(repo, subset, x): | ||||
|
r11383 | getargs(x, 0, 0, _("closed takes no arguments")) | ||
|
r11349 | return [r for r in subset if repo[r].extra().get('close')] | ||
|
r11275 | |||
def head(repo, subset, x): | ||||
|
r11383 | getargs(x, 0, 0, _("head takes no arguments")) | ||
|
r11275 | hs = set() | ||
for b, ls in repo.branchmap().iteritems(): | ||||
hs.update(repo[h].rev() for h in ls) | ||||
return [r for r in subset if r in hs] | ||||
def reverse(repo, subset, x): | ||||
l = getset(repo, subset, x) | ||||
l.reverse() | ||||
return l | ||||
|
r11944 | def present(repo, subset, x): | ||
try: | ||||
return getset(repo, subset, x) | ||||
except error.RepoLookupError: | ||||
return [] | ||||
|
r11275 | def sort(repo, subset, x): | ||
|
r11383 | l = getargs(x, 1, 2, _("sort wants one or two arguments")) | ||
|
r11275 | keys = "rev" | ||
if len(l) == 2: | ||||
|
r11383 | keys = getstring(l[1], _("sort spec must be a string")) | ||
|
r11275 | |||
s = l[0] | ||||
keys = keys.split() | ||||
l = [] | ||||
def invert(s): | ||||
return "".join(chr(255 - ord(c)) for c in s) | ||||
for r in getset(repo, subset, s): | ||||
c = repo[r] | ||||
e = [] | ||||
for k in keys: | ||||
if k == 'rev': | ||||
e.append(r) | ||||
elif k == '-rev': | ||||
e.append(-r) | ||||
elif k == 'branch': | ||||
e.append(c.branch()) | ||||
elif k == '-branch': | ||||
e.append(invert(c.branch())) | ||||
elif k == 'desc': | ||||
e.append(c.description()) | ||||
elif k == '-desc': | ||||
e.append(invert(c.description())) | ||||
elif k in 'user author': | ||||
e.append(c.user()) | ||||
elif k in '-user -author': | ||||
e.append(invert(c.user())) | ||||
elif k == 'date': | ||||
e.append(c.date()[0]) | ||||
elif k == '-date': | ||||
e.append(-c.date()[0]) | ||||
else: | ||||
|
r11383 | raise error.ParseError(_("unknown sort key %r") % k) | ||
|
r11275 | e.append(r) | ||
l.append(e) | ||||
l.sort() | ||||
return [e[-1] for e in l] | ||||
def getall(repo, subset, x): | ||||
|
r11383 | getargs(x, 0, 0, _("all takes no arguments")) | ||
|
r11275 | return subset | ||
def heads(repo, subset, x): | ||||
s = getset(repo, subset, x) | ||||
ps = set(parents(repo, subset, x)) | ||||
return [r for r in s if r not in ps] | ||||
def roots(repo, subset, x): | ||||
s = getset(repo, subset, x) | ||||
cs = set(children(repo, subset, x)) | ||||
return [r for r in s if r not in cs] | ||||
def outgoing(repo, subset, x): | ||||
|
r11293 | import hg # avoid start-up nasties | ||
|
r11383 | l = getargs(x, 0, 1, _("outgoing wants a repository path")) | ||
|
r11882 | dest = l and getstring(l[0], _("outgoing wants a repository path")) or '' | ||
|
r11275 | dest = repo.ui.expandpath(dest or 'default-push', dest or 'default') | ||
dest, branches = hg.parseurl(dest) | ||||
other = hg.repository(hg.remoteui(repo, {}), dest) | ||||
repo.ui.pushbuffer() | ||||
|
r11301 | o = discovery.findoutgoing(repo, other) | ||
|
r11275 | repo.ui.popbuffer() | ||
cl = repo.changelog | ||||
o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, None)[0]]) | ||||
return [r for r in subset if r in o] | ||||
|
r11280 | def tagged(repo, subset, x): | ||
|
r11383 | getargs(x, 0, 0, _("tagged takes no arguments")) | ||
|
r11280 | cl = repo.changelog | ||
s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip']) | ||||
return [r for r in subset if r in s] | ||||
|
r11275 | symbols = { | ||
|
r11284 | "adds": adds, | ||
"all": getall, | ||||
|
r11275 | "ancestor": ancestor, | ||
"ancestors": ancestors, | ||||
|
r11284 | "author": author, | ||
|
r11275 | "branch": branch, | ||
|
r11284 | "children": children, | ||
"closed": closed, | ||||
"contains": contains, | ||||
"date": date, | ||||
"descendants": descendants, | ||||
"file": hasfile, | ||||
"follow": follow, | ||||
"grep": grep, | ||||
"head": head, | ||||
"heads": heads, | ||||
|
r11275 | "keyword": keyword, | ||
|
r11284 | "limit": limit, | ||
"max": maxrev, | ||||
|
r11708 | "min": minrev, | ||
|
r11284 | "merge": merge, | ||
"modifies": modifies, | ||||
"outgoing": outgoing, | ||||
|
r11275 | "p1": p1, | ||
"p2": p2, | ||||
"parents": parents, | ||||
|
r11944 | "present": present, | ||
|
r11284 | "removes": removes, | ||
"reverse": reverse, | ||||
|
r11275 | "roots": roots, | ||
|
r11284 | "sort": sort, | ||
|
r11280 | "tagged": tagged, | ||
|
r11284 | "user": author, | ||
|
r11275 | } | ||
methods = { | ||||
"range": rangeset, | ||||
"string": stringset, | ||||
"symbol": symbolset, | ||||
"and": andset, | ||||
"or": orset, | ||||
"not": notset, | ||||
"list": listset, | ||||
"func": func, | ||||
} | ||||
|
r11279 | def optimize(x, small): | ||
if x == None: | ||||
return 0, x | ||||
|
r11275 | smallbonus = 1 | ||
if small: | ||||
smallbonus = .5 | ||||
op = x[0] | ||||
|
r11283 | if op == 'minus': | ||
|
r11279 | return optimize(('and', x[1], ('not', x[2])), small) | ||
elif op == 'dagrange': | ||||
return optimize(('and', ('func', ('symbol', 'descendants'), x[1]), | ||||
('func', ('symbol', 'ancestors'), x[2])), small) | ||||
elif op == 'dagrangepre': | ||||
return optimize(('func', ('symbol', 'ancestors'), x[1]), small) | ||||
elif op == 'dagrangepost': | ||||
return optimize(('func', ('symbol', 'descendants'), x[1]), small) | ||||
elif op == 'rangepre': | ||||
return optimize(('range', ('string', '0'), x[1]), small) | ||||
elif op == 'rangepost': | ||||
return optimize(('range', x[1], ('string', 'tip')), small) | ||||
|
r11467 | elif op == 'negate': | ||
return optimize(('string', | ||||
'-' + getstring(x[1], _("can't negate that"))), small) | ||||
|
r11279 | elif op in 'string symbol negate': | ||
return smallbonus, x # single revisions are small | ||||
|
r12401 | elif op == 'and' or op == 'dagrange': | ||
|
r11279 | wa, ta = optimize(x[1], True) | ||
wb, tb = optimize(x[2], True) | ||||
w = min(wa, wb) | ||||
if wa > wb: | ||||
return w, (op, tb, ta) | ||||
return w, (op, ta, tb) | ||||
elif op == 'or': | ||||
wa, ta = optimize(x[1], False) | ||||
wb, tb = optimize(x[2], False) | ||||
if wb < wa: | ||||
wb, wa = wa, wb | ||||
return max(wa, wb), (op, ta, tb) | ||||
|
r11275 | elif op == 'not': | ||
|
r11279 | o = optimize(x[1], not small) | ||
return o[0], (op, o[1]) | ||||
|
r11275 | elif op == 'group': | ||
|
r11279 | return optimize(x[1], small) | ||
elif op in 'range list': | ||||
wa, ta = optimize(x[1], small) | ||||
wb, tb = optimize(x[2], small) | ||||
return wa + wb, (op, ta, tb) | ||||
|
r11275 | elif op == 'func': | ||
|
r11383 | f = getstring(x[1], _("not a symbol")) | ||
|
r11279 | wa, ta = optimize(x[2], small) | ||
|
r12351 | if f in "grep date user author keyword branch file outgoing": | ||
|
r11279 | w = 10 # slow | ||
|
r12351 | elif f in "modifies adds removes": | ||
|
r11279 | w = 30 # slower | ||
|
r11275 | elif f == "contains": | ||
|
r11279 | w = 100 # very slow | ||
|
r11275 | elif f == "ancestor": | ||
|
r11279 | w = 1 * smallbonus | ||
|
r11275 | elif f == "reverse limit": | ||
|
r11279 | w = 0 | ||
|
r11275 | elif f in "sort": | ||
|
r11279 | w = 10 # assume most sorts look at changelog | ||
|
r11275 | else: | ||
|
r11279 | w = 1 | ||
return w + wa, (op, x[1], ta) | ||||
return 1, x | ||||
|
r11275 | |||
parse = parser.parser(tokenize, elements).parse | ||||
def match(spec): | ||||
|
r11385 | if not spec: | ||
raise error.ParseError(_("empty query")) | ||||
|
r11275 | tree = parse(spec) | ||
|
r11279 | weight, tree = optimize(tree, True) | ||
|
r11275 | def mfunc(repo, subset): | ||
return getset(repo, subset, tree) | ||||
return mfunc | ||||