fileset.py
663 lines
| 20.4 KiB
| text/x-python
|
PythonLexer
/ mercurial / fileset.py
|
r14511 | # fileset.py - file 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. | ||||
|
r25938 | from __future__ import absolute_import | ||
|
r20034 | import re | ||
|
r25938 | |||
from .i18n import _ | ||||
from . import ( | ||||
error, | ||||
|
r35757 | match as matchmod, | ||
|
r25938 | merge, | ||
parser, | ||||
|
r32523 | pycompat, | ||
|
r28448 | registrar, | ||
|
r31193 | scmutil, | ||
|
r25938 | util, | ||
) | ||||
|
r37102 | from .utils import ( | ||
stringutil, | ||||
) | ||||
|
r14511 | |||
elements = { | ||||
|
r25815 | # token-type: binding-strength, primary, prefix, infix, suffix | ||
"(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None), | ||||
|
r35759 | ":": (15, None, None, ("kindpat", 15), None), | ||
|
r25815 | "-": (5, None, ("negate", 19), ("minus", 5), None), | ||
"not": (10, None, ("not", 10), None, None), | ||||
"!": (10, None, ("not", 10), None, None), | ||||
"and": (5, None, None, ("and", 5), None), | ||||
"&": (5, None, None, ("and", 5), None), | ||||
"or": (4, None, None, ("or", 4), None), | ||||
"|": (4, None, None, ("or", 4), None), | ||||
"+": (4, None, None, ("or", 4), None), | ||||
",": (2, None, None, ("list", 2), None), | ||||
")": (0, None, None, None, None), | ||||
"symbol": (0, "symbol", None, None, None), | ||||
"string": (0, "string", None, None, None), | ||||
"end": (0, None, None, None, None), | ||||
|
r14511 | } | ||
|
r32291 | keywords = {'and', 'or', 'not'} | ||
|
r14511 | |||
|
r19470 | globchars = ".*{}[]?/\\_" | ||
|
r14551 | |||
|
r14511 | def tokenize(program): | ||
pos, l = 0, len(program) | ||||
|
r32523 | program = pycompat.bytestr(program) | ||
|
r14511 | while pos < l: | ||
c = program[pos] | ||||
if c.isspace(): # skip inter-token whitespace | ||||
pass | ||||
|
r35759 | elif c in "(),-:|&+!": # handle simple operators | ||
|
r14511 | yield (c, None, pos) | ||
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: | ||||
|
r26233 | decode = parser.unescapestr | ||
|
r14511 | 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: | ||||
yield ('string', decode(program[s:pos]), s) | ||||
break | ||||
pos += 1 | ||||
else: | ||||
raise error.ParseError(_("unterminated string"), s) | ||||
|
r14551 | elif c.isalnum() or c in globchars or ord(c) > 127: | ||
|
r14513 | # gather up a symbol/keyword | ||
|
r14511 | s = pos | ||
pos += 1 | ||||
while pos < l: # find end of symbol | ||||
d = program[pos] | ||||
|
r14551 | if not (d.isalnum() or d in globchars or ord(d) > 127): | ||
|
r14511 | break | ||
pos += 1 | ||||
sym = program[s:pos] | ||||
if sym in keywords: # operator keywords | ||||
yield (sym, None, s) | ||||
else: | ||||
yield ('symbol', sym, s) | ||||
pos -= 1 | ||||
else: | ||||
raise error.ParseError(_("syntax error"), pos) | ||||
pos += 1 | ||||
yield ('end', None, pos) | ||||
|
r20208 | def parse(expr): | ||
|
r25654 | p = parser.parser(elements) | ||
tree, pos = p.parse(tokenize(expr)) | ||||
|
r25252 | if pos != len(expr): | ||
raise error.ParseError(_("invalid token"), pos) | ||||
return tree | ||||
|
r14511 | |||
|
r35709 | def getsymbol(x): | ||
if x and x[0] == 'symbol': | ||||
return x[1] | ||||
raise error.ParseError(_('not a symbol')) | ||||
|
r14551 | def getstring(x, err): | ||
if x and (x[0] == 'string' or x[0] == 'symbol'): | ||||
return x[1] | ||||
raise error.ParseError(err) | ||||
|
r35759 | def _getkindpat(x, y, allkinds, err): | ||
kind = getsymbol(x) | ||||
pat = getstring(y, err) | ||||
if kind not in allkinds: | ||||
raise error.ParseError(_("invalid pattern kind: %s") % kind) | ||||
return '%s:%s' % (kind, pat) | ||||
def getpattern(x, allkinds, err): | ||||
if x and x[0] == 'kindpat': | ||||
return _getkindpat(x[1], x[2], allkinds, err) | ||||
return getstring(x, err) | ||||
|
r14551 | def getset(mctx, x): | ||
if not x: | ||||
raise error.ParseError(_("missing argument")) | ||||
return methods[x[0]](mctx, *x[1:]) | ||||
def stringset(mctx, x): | ||||
m = mctx.matcher([x]) | ||||
return [f for f in mctx.subset if m(f)] | ||||
|
r35759 | def kindpatset(mctx, x, y): | ||
return stringset(mctx, _getkindpat(x, y, matchmod.allpatternkinds, | ||||
_("pattern must be a string"))) | ||||
|
r14551 | def andset(mctx, x, y): | ||
return getset(mctx.narrow(getset(mctx, x)), y) | ||||
def orset(mctx, x, y): | ||||
# needs optimizing | ||||
xl = getset(mctx, x) | ||||
yl = getset(mctx, y) | ||||
return xl + [f for f in yl if f not in xl] | ||||
def notset(mctx, x): | ||||
s = set(getset(mctx, x)) | ||||
return [r for r in mctx.subset if r not in s] | ||||
|
r17363 | def minusset(mctx, x, y): | ||
xl = getset(mctx, x) | ||||
yl = set(getset(mctx, y)) | ||||
return [f for f in xl if f not in yl] | ||||
|
r35710 | def negateset(mctx, x): | ||
raise error.ParseError(_("can't use negate operator in this context")) | ||||
|
r14551 | def listset(mctx, a, b): | ||
|
r27518 | raise error.ParseError(_("can't use a list in this context"), | ||
hint=_('see hg help "filesets.x or y"')) | ||||
|
r14551 | |||
|
r27460 | # symbols are callable like: | ||
# fun(mctx, x) | ||||
# with: | ||||
# mctx - current matchctx instance | ||||
# x - argument in tree form | ||||
symbols = {} | ||||
|
r27461 | # filesets using matchctx.status() | ||
|
r27463 | _statuscallers = set() | ||
|
r27461 | |||
|
r27462 | # filesets using matchctx.existing() | ||
|
r27463 | _existingcallers = set() | ||
|
r27462 | |||
|
r28448 | predicate = registrar.filesetpredicate() | ||
|
r27460 | |||
|
r27461 | @predicate('modified()', callstatus=True) | ||
|
r14677 | def modified(mctx, x): | ||
|
r27460 | """File that is modified according to :hg:`status`. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "modified" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("modified takes no arguments")) | ||
|
r31697 | s = set(mctx.status().modified) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('added()', callstatus=True) | ||
|
r14677 | def added(mctx, x): | ||
|
r27460 | """File that is added according to :hg:`status`. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "added" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("added takes no arguments")) | ||
|
r31697 | s = set(mctx.status().added) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('removed()', callstatus=True) | ||
|
r14677 | def removed(mctx, x): | ||
|
r27460 | """File that is removed according to :hg:`status`. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "removed" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("removed takes no arguments")) | ||
|
r31697 | s = set(mctx.status().removed) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('deleted()', callstatus=True) | ||
|
r14677 | def deleted(mctx, x): | ||
|
r27460 | """Alias for ``missing()``. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "deleted" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("deleted takes no arguments")) | ||
|
r31697 | s = set(mctx.status().deleted) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('missing()', callstatus=True) | ||
|
r27024 | def missing(mctx, x): | ||
|
r27460 | """File that is missing according to :hg:`status`. | ||
|
r27024 | """ | ||
# i18n: "missing" is a keyword | ||||
getargs(x, 0, 0, _("missing takes no arguments")) | ||||
|
r31697 | s = set(mctx.status().deleted) | ||
|
r27024 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('unknown()', callstatus=True) | ||
|
r14677 | def unknown(mctx, x): | ||
|
r27460 | """File that is unknown according to :hg:`status`. These files will only be | ||
|
r14681 | considered if this predicate is used. | ||
""" | ||||
|
r14785 | # i18n: "unknown" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("unknown takes no arguments")) | ||
|
r31697 | s = set(mctx.status().unknown) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('ignored()', callstatus=True) | ||
|
r14677 | def ignored(mctx, x): | ||
|
r27460 | """File that is ignored according to :hg:`status`. These files will only be | ||
|
r14681 | considered if this predicate is used. | ||
""" | ||||
|
r14785 | # i18n: "ignored" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("ignored takes no arguments")) | ||
|
r31697 | s = set(mctx.status().ignored) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r27461 | @predicate('clean()', callstatus=True) | ||
|
r14677 | def clean(mctx, x): | ||
|
r27460 | """File that is clean according to :hg:`status`. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "clean" is a keyword | ||
|
r14677 | getargs(x, 0, 0, _("clean takes no arguments")) | ||
|
r31697 | s = set(mctx.status().clean) | ||
|
r14677 | return [f for f in mctx.subset if f in s] | ||
|
r14676 | def func(mctx, a, b): | ||
|
r35709 | funcname = getsymbol(a) | ||
if funcname in symbols: | ||||
|
r27464 | enabled = mctx._existingenabled | ||
mctx._existingenabled = funcname in _existingcallers | ||||
try: | ||||
return symbols[funcname](mctx, b) | ||||
finally: | ||||
mctx._existingenabled = enabled | ||||
|
r25633 | |||
keep = lambda fn: getattr(fn, '__doc__', None) is not None | ||||
syms = [s for (s, fn) in symbols.items() if keep(fn)] | ||||
|
r35709 | raise error.UnknownIdentifier(funcname, syms) | ||
|
r14676 | |||
def getlist(x): | ||||
if not x: | ||||
return [] | ||||
if x[0] == 'list': | ||||
return getlist(x[1]) + [x[2]] | ||||
return [x] | ||||
def getargs(x, min, max, err): | ||||
l = getlist(x) | ||||
if len(l) < min or len(l) > max: | ||||
raise error.ParseError(err) | ||||
return l | ||||
|
r27462 | @predicate('binary()', callexisting=True) | ||
|
r14676 | def binary(mctx, x): | ||
|
r27460 | """File that appears to be binary (contains NUL bytes). | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "binary" is a keyword | ||
|
r14676 | getargs(x, 0, 0, _("binary takes no arguments")) | ||
|
r32134 | return [f for f in mctx.existing() if mctx.ctx[f].isbinary()] | ||
|
r14676 | |||
|
r27462 | @predicate('exec()', callexisting=True) | ||
|
r14676 | def exec_(mctx, x): | ||
|
r27460 | """File that is marked as executable. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "exec" is a keyword | ||
|
r14676 | getargs(x, 0, 0, _("exec takes no arguments")) | ||
|
r15963 | return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'x'] | ||
|
r14676 | |||
|
r27462 | @predicate('symlink()', callexisting=True) | ||
|
r14676 | def symlink(mctx, x): | ||
|
r27460 | """File that is marked as a symlink. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "symlink" is a keyword | ||
|
r14676 | getargs(x, 0, 0, _("symlink takes no arguments")) | ||
|
r15963 | return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'l'] | ||
|
r14676 | |||
|
r27460 | @predicate('resolved()') | ||
|
r14679 | def resolved(mctx, x): | ||
|
r27460 | """File that is marked resolved according to :hg:`resolve -l`. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "resolved" is a keyword | ||
|
r14679 | getargs(x, 0, 0, _("resolved takes no arguments")) | ||
if mctx.ctx.rev() is not None: | ||||
return [] | ||||
|
r26995 | ms = merge.mergestate.read(mctx.ctx.repo()) | ||
|
r14679 | return [f for f in mctx.subset if f in ms and ms[f] == 'r'] | ||
|
r27460 | @predicate('unresolved()') | ||
|
r14679 | def unresolved(mctx, x): | ||
|
r27460 | """File that is marked unresolved according to :hg:`resolve -l`. | ||
|
r14681 | """ | ||
|
r14785 | # i18n: "unresolved" is a keyword | ||
|
r14679 | getargs(x, 0, 0, _("unresolved takes no arguments")) | ||
if mctx.ctx.rev() is not None: | ||||
return [] | ||||
|
r26995 | ms = merge.mergestate.read(mctx.ctx.repo()) | ||
|
r14679 | return [f for f in mctx.subset if f in ms and ms[f] == 'u'] | ||
|
r27460 | @predicate('hgignore()') | ||
|
r14680 | def hgignore(mctx, x): | ||
|
r27460 | """File that matches the active .hgignore pattern. | ||
|
r14681 | """ | ||
|
r23113 | # i18n: "hgignore" is a keyword | ||
|
r14680 | getargs(x, 0, 0, _("hgignore takes no arguments")) | ||
|
r24334 | ignore = mctx.ctx.repo().dirstate._ignore | ||
|
r14680 | return [f for f in mctx.subset if ignore(f)] | ||
|
r27460 | @predicate('portable()') | ||
|
r24408 | def portable(mctx, x): | ||
|
r27460 | """File that has a portable name. (This doesn't include filenames with case | ||
|
r24408 | collisions.) | ||
""" | ||||
# i18n: "portable" is a keyword | ||||
getargs(x, 0, 0, _("portable takes no arguments")) | ||||
checkwinfilename = util.checkwinfilename | ||||
return [f for f in mctx.subset if checkwinfilename(f) is None] | ||||
|
r27462 | @predicate('grep(regex)', callexisting=True) | ||
|
r14682 | def grep(mctx, x): | ||
|
r27460 | """File contains the given regular expression. | ||
|
r14682 | """ | ||
|
r17368 | try: | ||
# i18n: "grep" is a keyword | ||||
r = re.compile(getstring(x, _("grep requires a pattern"))) | ||||
|
r25660 | except re.error as e: | ||
|
r38094 | raise error.ParseError(_('invalid match pattern: %s') % | ||
stringutil.forcebytestr(e)) | ||||
|
r15963 | return [f for f in mctx.existing() if r.search(mctx.ctx[f].data())] | ||
|
r14682 | |||
|
r14683 | def _sizetomax(s): | ||
try: | ||||
r25925 | s = s.strip().lower() | |||
|
r19194 | for k, v in util._sizeunits: | ||
|
r14683 | if s.endswith(k): | ||
# max(4k) = 5k - 1, max(4.5k) = 4.6k - 1 | ||||
n = s[:-len(k)] | ||||
inc = 1.0 | ||||
if "." in n: | ||||
inc /= 10 ** len(n.split(".")[1]) | ||||
return int((float(n) + inc) * v) - 1 | ||||
# no extension, this is a precise value | ||||
return int(s) | ||||
except ValueError: | ||||
|
r14716 | raise error.ParseError(_("couldn't parse size: %s") % s) | ||
|
r14683 | |||
|
r35633 | def sizematcher(x): | ||
"""Return a function(size) -> bool from the ``size()`` expression""" | ||||
# i18n: "size" is a keyword | ||||
expr = getstring(x, _("size requires an expression")).strip() | ||||
if '-' in expr: # do we have a range? | ||||
a, b = expr.split('-', 1) | ||||
a = util.sizetoint(a) | ||||
b = util.sizetoint(b) | ||||
return lambda x: x >= a and x <= b | ||||
elif expr.startswith("<="): | ||||
a = util.sizetoint(expr[2:]) | ||||
return lambda x: x <= a | ||||
elif expr.startswith("<"): | ||||
a = util.sizetoint(expr[1:]) | ||||
return lambda x: x < a | ||||
elif expr.startswith(">="): | ||||
a = util.sizetoint(expr[2:]) | ||||
return lambda x: x >= a | ||||
elif expr.startswith(">"): | ||||
a = util.sizetoint(expr[1:]) | ||||
return lambda x: x > a | ||||
|
r36523 | else: | ||
|
r35633 | a = util.sizetoint(expr) | ||
b = _sizetomax(expr) | ||||
return lambda x: x >= a and x <= b | ||||
|
r27462 | @predicate('size(expression)', callexisting=True) | ||
|
r14683 | def size(mctx, x): | ||
|
r27460 | """File size matches the given expression. Examples: | ||
|
r14683 | |||
|
r29987 | - size('1k') - files from 1024 to 2047 bytes | ||
- size('< 20k') - files less than 20480 bytes | ||||
- size('>= .5MB') - files at least 524288 bytes | ||||
- size('4k - 1MB') - files from 4096 bytes to 1048576 bytes | ||||
|
r14683 | """ | ||
|
r35633 | m = sizematcher(x) | ||
|
r15963 | return [f for f in mctx.existing() if m(mctx.ctx[f].size())] | ||
|
r14683 | |||
|
r27462 | @predicate('encoding(name)', callexisting=True) | ||
|
r14684 | def encoding(mctx, x): | ||
|
r27460 | """File can be successfully decoded with the given character | ||
|
r14684 | encoding. May not be useful for encodings other than ASCII and | ||
UTF-8. | ||||
""" | ||||
|
r14785 | # i18n: "encoding" is a keyword | ||
|
r14684 | enc = getstring(x, _("encoding requires an encoding name")) | ||
s = [] | ||||
|
r15963 | for f in mctx.existing(): | ||
|
r14684 | d = mctx.ctx[f].data() | ||
try: | ||||
d.decode(enc) | ||||
except LookupError: | ||||
|
r26587 | raise error.Abort(_("unknown encoding '%s'") % enc) | ||
|
r14684 | except UnicodeDecodeError: | ||
continue | ||||
s.append(f) | ||||
return s | ||||
|
r27462 | @predicate('eol(style)', callexisting=True) | ||
|
r18842 | def eol(mctx, x): | ||
|
r27460 | """File contains newlines of the given style (dos, unix, mac). Binary | ||
|
r18842 | files are excluded, files with mixed line endings match multiple | ||
styles. | ||||
""" | ||||
|
r28056 | # i18n: "eol" is a keyword | ||
enc = getstring(x, _("eol requires a style name")) | ||||
|
r18842 | |||
s = [] | ||||
for f in mctx.existing(): | ||||
d = mctx.ctx[f].data() | ||||
|
r37102 | if stringutil.binary(d): | ||
|
r18842 | continue | ||
if (enc == 'dos' or enc == 'win') and '\r\n' in d: | ||||
s.append(f) | ||||
elif enc == 'unix' and re.search('(?<!\r)\n', d): | ||||
s.append(f) | ||||
elif enc == 'mac' and re.search('\r(?!\n)', d): | ||||
s.append(f) | ||||
return s | ||||
|
r27460 | @predicate('copied()') | ||
|
r14685 | def copied(mctx, x): | ||
|
r27460 | """File that is recorded as being copied. | ||
|
r14685 | """ | ||
|
r14785 | # i18n: "copied" is a keyword | ||
|
r14718 | getargs(x, 0, 0, _("copied takes no arguments")) | ||
|
r14685 | s = [] | ||
for f in mctx.subset: | ||||
|
r35968 | if f in mctx.ctx: | ||
p = mctx.ctx[f].parents() | ||||
if p and p[0].path() != f: | ||||
s.append(f) | ||||
|
r14685 | return s | ||
|
r31193 | @predicate('revs(revs, pattern)') | ||
def revs(mctx, x): | ||||
|
r31254 | """Evaluate set in the specified revisions. If the revset match multiple | ||
revs, this will return file matching pattern in any of the revision. | ||||
|
r31193 | """ | ||
# i18n: "revs" is a keyword | ||||
r, x = getargs(x, 2, 2, _("revs takes two arguments")) | ||||
# i18n: "revs" is a keyword | ||||
revspec = getstring(r, _("first argument to revs must be a revision")) | ||||
repo = mctx.ctx.repo() | ||||
revs = scmutil.revrange(repo, [revspec]) | ||||
found = set() | ||||
result = [] | ||||
for r in revs: | ||||
ctx = repo[r] | ||||
for f in getset(mctx.switch(ctx, _buildstatus(ctx, x)), x): | ||||
if f not in found: | ||||
found.add(f) | ||||
result.append(f) | ||||
return result | ||||
|
r31195 | @predicate('status(base, rev, pattern)') | ||
def status(mctx, x): | ||||
|
r31254 | """Evaluate predicate using status change between ``base`` and | ||
|
r31195 | ``rev``. Examples: | ||
- ``status(3, 7, added())`` - matches files added from "3" to "7" | ||||
""" | ||||
repo = mctx.ctx.repo() | ||||
# i18n: "status" is a keyword | ||||
b, r, x = getargs(x, 3, 3, _("status takes three arguments")) | ||||
# i18n: "status" is a keyword | ||||
baseerr = _("first argument to status must be a revision") | ||||
baserevspec = getstring(b, baseerr) | ||||
if not baserevspec: | ||||
raise error.ParseError(baseerr) | ||||
reverr = _("second argument to status must be a revision") | ||||
revspec = getstring(r, reverr) | ||||
if not revspec: | ||||
raise error.ParseError(reverr) | ||||
|
r37274 | basectx, ctx = scmutil.revpair(repo, [baserevspec, revspec]) | ||
|
r31195 | return getset(mctx.switch(ctx, _buildstatus(ctx, x, basectx=basectx)), x) | ||
|
r27460 | @predicate('subrepo([pattern])') | ||
|
r16443 | def subrepo(mctx, x): | ||
|
r27460 | """Subrepositories whose paths match the given pattern. | ||
|
r16443 | """ | ||
# i18n: "subrepo" is a keyword | ||||
getargs(x, 0, 1, _("subrepo takes at most one argument")) | ||||
ctx = mctx.ctx | ||||
|
r18364 | sstate = sorted(ctx.substate) | ||
|
r16443 | if x: | ||
|
r35759 | pat = getpattern(x, matchmod.allpatternkinds, | ||
# i18n: "subrepo" is a keyword | ||||
_("subrepo requires a pattern or no arguments")) | ||||
|
r16443 | fast = not matchmod.patkind(pat) | ||
if fast: | ||||
def m(s): | ||||
return (s == pat) | ||||
else: | ||||
|
r24334 | m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx) | ||
|
r16443 | return [sub for sub in sstate if m(sub)] | ||
else: | ||||
return [sub for sub in sstate] | ||||
|
r14551 | methods = { | ||
'string': stringset, | ||||
'symbol': stringset, | ||||
|
r35759 | 'kindpat': kindpatset, | ||
|
r14551 | 'and': andset, | ||
'or': orset, | ||||
|
r17363 | 'minus': minusset, | ||
|
r35710 | 'negate': negateset, | ||
|
r14551 | 'list': listset, | ||
'group': getset, | ||||
|
r14676 | 'not': notset, | ||
'func': func, | ||||
|
r14551 | } | ||
class matchctx(object): | ||||
|
r31190 | def __init__(self, ctx, subset, status=None): | ||
|
r14551 | self.ctx = ctx | ||
self.subset = subset | ||||
|
r14677 | self._status = status | ||
|
r27464 | self._existingenabled = False | ||
|
r14677 | def status(self): | ||
return self._status | ||||
|
r14673 | def matcher(self, patterns): | ||
return self.ctx.match(patterns) | ||||
|
r14551 | def filter(self, files): | ||
return [f for f in files if f in self.subset] | ||||
|
r15963 | def existing(self): | ||
|
r27464 | assert self._existingenabled, 'unexpected existing() invocation' | ||
|
r17365 | if self._status is not None: | ||
removed = set(self._status[3]) | ||||
|
r17367 | unknown = set(self._status[4] + self._status[5]) | ||
|
r17365 | else: | ||
removed = set() | ||||
|
r17366 | unknown = set() | ||
|
r17365 | return (f for f in self.subset | ||
|
r17366 | if (f in self.ctx and f not in removed) or f in unknown) | ||
|
r14551 | def narrow(self, files): | ||
|
r14677 | return matchctx(self.ctx, self.filter(files), self._status) | ||
|
r31192 | def switch(self, ctx, status=None): | ||
subset = self.filter(_buildsubset(ctx, status)) | ||||
return matchctx(ctx, subset, status) | ||||
|
r14551 | |||
|
r31188 | class fullmatchctx(matchctx): | ||
"""A match context where any files in any revisions should be valid""" | ||||
|
r31190 | def __init__(self, ctx, status=None): | ||
subset = _buildsubset(ctx, status) | ||||
|
r31188 | super(fullmatchctx, self).__init__(ctx, subset, status) | ||
|
r31192 | def switch(self, ctx, status=None): | ||
return fullmatchctx(ctx, status) | ||||
# filesets using matchctx.switch() | ||||
_switchcallers = [ | ||||
|
r31193 | 'revs', | ||
|
r31195 | 'status', | ||
|
r31192 | ] | ||
|
r31188 | |||
|
r14678 | def _intree(funcs, tree): | ||
if isinstance(tree, tuple): | ||||
if tree[0] == 'func' and tree[1][0] == 'symbol': | ||||
if tree[1][1] in funcs: | ||||
return True | ||||
|
r31192 | if tree[1][1] in _switchcallers: | ||
# arguments won't be evaluated in the current context | ||||
return False | ||||
|
r14678 | for s in tree[1:]: | ||
if _intree(funcs, s): | ||||
return True | ||||
return False | ||||
|
r31189 | def _buildsubset(ctx, status): | ||
if status: | ||||
subset = [] | ||||
for c in status: | ||||
subset.extend(c) | ||||
return subset | ||||
else: | ||||
return list(ctx.walk(ctx.match([]))) | ||||
|
r14673 | def getfileset(ctx, expr): | ||
|
r25252 | tree = parse(expr) | ||
|
r31191 | return getset(fullmatchctx(ctx, _buildstatus(ctx, tree)), tree) | ||
|
r14678 | |||
|
r31194 | def _buildstatus(ctx, tree, basectx=None): | ||
|
r14678 | # do we need status info? | ||
|
r31194 | |||
# temporaty boolean to simplify the next conditional | ||||
purewdir = ctx.rev() is None and basectx is None | ||||
|
r27461 | if (_intree(_statuscallers, tree) or | ||
|
r17365 | # Using matchctx.existing() on a workingctx requires us to check | ||
# for deleted files. | ||||
|
r31194 | (purewdir and _intree(_existingcallers, tree))): | ||
|
r14678 | unknown = _intree(['unknown'], tree) | ||
ignored = _intree(['ignored'], tree) | ||||
|
r24334 | r = ctx.repo() | ||
|
r31194 | if basectx is None: | ||
basectx = ctx.p1() | ||||
return r.status(basectx, ctx, | ||||
|
r31191 | unknown=unknown, ignored=ignored, clean=True) | ||
|
r14678 | else: | ||
|
r31191 | return None | ||
|
r14681 | |||
|
r25255 | def prettyformat(tree): | ||
return parser.prettyformat(tree, ('string', 'symbol')) | ||||
|
r28447 | def loadpredicate(ui, extname, registrarobj): | ||
"""Load fileset predicates from specified registrarobj | ||||
""" | ||||
for name, func in registrarobj._table.iteritems(): | ||||
symbols[name] = func | ||||
if func._callstatus: | ||||
_statuscallers.add(name) | ||||
if func._callexisting: | ||||
_existingcallers.add(name) | ||||
|
r28448 | # load built-in predicates explicitly to setup _statuscallers/_existingcallers | ||
loadpredicate(None, None, predicate) | ||||
|
r14681 | # tell hggettext to extract docstrings from these functions: | ||
i18nfunctions = symbols.values() | ||||