mercurial-scm/hg: comparison mercurial/fileset.py

equal deleted inserted replaced

-:2570dca0f21c
+:ff5b6fca1082
 l = getlist(x)
 if len(l) < min or len(l) > max:
 raise error.ParseError(err)
 return l
-def getset(mctx, x):
+def getmatch(mctx, x):
 if not x:
 raise error.ParseError(_("missing argument"))
 return methods[x[0]](mctx, *x[1:])
-def stringset(mctx, x):
+def stringmatch(mctx, x):
-m = mctx.matcher([x])
+return mctx.matcher([x])
-return [f for f in mctx.subset if m(f)]
+def kindpatmatch(mctx, x, y):
-def kindpatset(mctx, x, y):
+return stringmatch(mctx, _getkindpat(x, y, matchmod.allpatternkinds,
-return stringset(mctx, _getkindpat(x, y, matchmod.allpatternkinds,
+_("pattern must be a string")))
-_("pattern must be a string")))
+def andmatch(mctx, x, y):
-def andset(mctx, x, y):
+xm = getmatch(mctx, x)
-xl = set(getset(mctx, x))
+ym = getmatch(mctx, y)
-yl = getset(mctx, y)
+return matchmod.intersectmatchers(xm, ym)
-return [f for f in yl if f in xl]
+def ormatch(mctx, x, y):
-def orset(mctx, x, y):
+xm = getmatch(mctx, x)
-# needs optimizing
+ym = getmatch(mctx, y)
-xl = getset(mctx, x)
+return matchmod.unionmatcher([xm, ym])
-yl = getset(mctx, y)
-return xl + [f for f in yl if f not in xl]
+def notmatch(mctx, x):
+m = getmatch(mctx, x)
-def notset(mctx, x):
+return mctx.predicate(lambda f: not m(f), predrepr=('<not %r>', m))
-s = set(getset(mctx, x))
-return [r for r in mctx.subset if r not in s]
+def minusmatch(mctx, x, y):
+xm = getmatch(mctx, x)
-def minusset(mctx, x, y):
+ym = getmatch(mctx, y)
-xl = getset(mctx, x)
+return matchmod.differencematcher(xm, ym)
-yl = set(getset(mctx, y))
-return [f for f in xl if f not in yl]
+def negatematch(mctx, x):
-def negateset(mctx, x):
 raise error.ParseError(_("can't use negate operator in this context"))
-def listset(mctx, a, b):
+def listmatch(mctx, x, y):
 raise error.ParseError(_("can't use a list in this context"),
 hint=_('see hg help "filesets.x or y"'))
 def func(mctx, a, b):
 funcname = getsymbol(a)
 """File that is modified according to :hg:`status`.
 """
 # i18n: "modified" is a keyword
 getargs(x, 0, 0, _("modified takes no arguments"))
 s = set(mctx.status().modified)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='modified')
 @predicate('added()', callstatus=True)
 def added(mctx, x):
 """File that is added according to :hg:`status`.
 """
 # i18n: "added" is a keyword
 getargs(x, 0, 0, _("added takes no arguments"))
 s = set(mctx.status().added)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='added')
 @predicate('removed()', callstatus=True)
 def removed(mctx, x):
 """File that is removed according to :hg:`status`.
 """
 # i18n: "removed" is a keyword
 getargs(x, 0, 0, _("removed takes no arguments"))
 s = set(mctx.status().removed)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='removed')
 @predicate('deleted()', callstatus=True)
 def deleted(mctx, x):
 """Alias for ``missing()``.
 """
 # i18n: "deleted" is a keyword
 getargs(x, 0, 0, _("deleted takes no arguments"))
 s = set(mctx.status().deleted)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='deleted')
 @predicate('missing()', callstatus=True)
 def missing(mctx, x):
 """File that is missing according to :hg:`status`.
 """
 # i18n: "missing" is a keyword
 getargs(x, 0, 0, _("missing takes no arguments"))
 s = set(mctx.status().deleted)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='deleted')
 @predicate('unknown()', callstatus=True)
 def unknown(mctx, x):
-"""File that is unknown according to :hg:`status`. These files will only be
+"""File that is unknown according to :hg:`status`."""
-considered if this predicate is used.
-"""
 # i18n: "unknown" is a keyword
 getargs(x, 0, 0, _("unknown takes no arguments"))
 s = set(mctx.status().unknown)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='unknown')
 @predicate('ignored()', callstatus=True)
 def ignored(mctx, x):
-"""File that is ignored according to :hg:`status`. These files will only be
+"""File that is ignored according to :hg:`status`."""
-considered if this predicate is used.
-"""
 # i18n: "ignored" is a keyword
 getargs(x, 0, 0, _("ignored takes no arguments"))
 s = set(mctx.status().ignored)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='ignored')
 @predicate('clean()', callstatus=True)
 def clean(mctx, x):
 """File that is clean according to :hg:`status`.
 """
 # i18n: "clean" is a keyword
 getargs(x, 0, 0, _("clean takes no arguments"))
 s = set(mctx.status().clean)
-return [f for f in mctx.subset if f in s]
+return mctx.predicate(s.__contains__, predrepr='clean')
 @predicate('tracked()')
 def tracked(mctx, x):
 """File that is under Mercurial control."""
 # i18n: "tracked" is a keyword
 getargs(x, 0, 0, _("tracked takes no arguments"))
-return [f for f in mctx.subset if f in mctx.ctx]
+return mctx.predicate(mctx.ctx.__contains__, predrepr='tracked')
 @predicate('binary()', callexisting=True)
 def binary(mctx, x):
 """File that appears to be binary (contains NUL bytes).
 """
 # i18n: "binary" is a keyword
 getargs(x, 0, 0, _("binary takes no arguments"))
-return [f for f in mctx.existing() if mctx.ctx[f].isbinary()]
+return mctx.fpredicate(lambda fctx: fctx.isbinary(),
+predrepr='binary', cache=True)
 @predicate('exec()', callexisting=True)
 def exec_(mctx, x):
 """File that is marked as executable.
 """
 # i18n: "exec" is a keyword
 getargs(x, 0, 0, _("exec takes no arguments"))
-return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'x']
+ctx = mctx.ctx
+return mctx.predicate(lambda f: ctx.flags(f) == 'x', predrepr='exec')
 @predicate('symlink()', callexisting=True)
 def symlink(mctx, x):
 """File that is marked as a symlink.
 """
 # i18n: "symlink" is a keyword
 getargs(x, 0, 0, _("symlink takes no arguments"))
-return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'l']
+ctx = mctx.ctx
+return mctx.predicate(lambda f: ctx.flags(f) == 'l', predrepr='symlink')
 @predicate('resolved()')
 def resolved(mctx, x):
 """File that is marked resolved according to :hg:`resolve -l`.
 """
 # i18n: "resolved" is a keyword
 getargs(x, 0, 0, _("resolved takes no arguments"))
 if mctx.ctx.rev() is not None:
-return []
+return mctx.never()
 ms = merge.mergestate.read(mctx.ctx.repo())
-return [f for f in mctx.subset if f in ms and ms[f] == 'r']
+return mctx.predicate(lambda f: f in ms and ms[f] == 'r',
+predrepr='resolved')
 @predicate('unresolved()')
 def unresolved(mctx, x):
 """File that is marked unresolved according to :hg:`resolve -l`.
 """
 # i18n: "unresolved" is a keyword
 getargs(x, 0, 0, _("unresolved takes no arguments"))
 if mctx.ctx.rev() is not None:
-return []
+return mctx.never()
 ms = merge.mergestate.read(mctx.ctx.repo())
-return [f for f in mctx.subset if f in ms and ms[f] == 'u']
+return mctx.predicate(lambda f: f in ms and ms[f] == 'u',
+predrepr='unresolved')
 @predicate('hgignore()')
 def hgignore(mctx, x):
 """File that matches the active .hgignore pattern.
 """
 # i18n: "hgignore" is a keyword
 getargs(x, 0, 0, _("hgignore takes no arguments"))
-ignore = mctx.ctx.repo().dirstate._ignore
+return mctx.ctx.repo().dirstate._ignore
-return [f for f in mctx.subset if ignore(f)]
 @predicate('portable()')
 def portable(mctx, x):
 """File that has a portable name. (This doesn't include filenames with case
 collisions.)
 """
 # i18n: "portable" is a keyword
 getargs(x, 0, 0, _("portable takes no arguments"))
-checkwinfilename = util.checkwinfilename
+return mctx.predicate(lambda f: util.checkwinfilename(f) is None,
-return [f for f in mctx.subset if checkwinfilename(f) is None]
+predrepr='portable')
 @predicate('grep(regex)', callexisting=True)
 def grep(mctx, x):
 """File contains the given regular expression.
 """
 # i18n: "grep" is a keyword
 r = re.compile(getstring(x, _("grep requires a pattern")))
 except re.error as e:
 raise error.ParseError(_('invalid match pattern: %s') %
 stringutil.forcebytestr(e))
-return [f for f in mctx.existing() if r.search(mctx.ctx[f].data())]
+return mctx.fpredicate(lambda fctx: r.search(fctx.data()),
+predrepr=('grep(%r)', r.pattern), cache=True)
 def _sizetomax(s):
 try:
 s = s.strip().lower()
 for k, v in util._sizeunits:
 - size('4k - 1MB') - files from 4096 bytes to 1048576 bytes
 """
 # i18n: "size" is a keyword
 expr = getstring(x, _("size requires an expression"))
 m = sizematcher(expr)
-return [f for f in mctx.existing() if m(mctx.ctx[f].size())]
+return mctx.fpredicate(lambda fctx: m(fctx.size()),
+predrepr=('size(%r)', expr), cache=True)
 @predicate('encoding(name)', callexisting=True)
 def encoding(mctx, x):
 """File can be successfully decoded with the given character
 encoding. May not be useful for encodings other than ASCII and
 """
 # i18n: "encoding" is a keyword
 enc = getstring(x, _("encoding requires an encoding name"))
-s = []
+def encp(fctx):
-for f in mctx.existing():
+d = fctx.data()
-d = mctx.ctx[f].data()
 try:
 d.decode(pycompat.sysstr(enc))
+return True
 except LookupError:
 raise error.Abort(_("unknown encoding '%s'") % enc)
 except UnicodeDecodeError:
-continue
+return False
-s.append(f)
+return mctx.fpredicate(encp, predrepr=('encoding(%r)', enc), cache=True)
-return s
 @predicate('eol(style)', callexisting=True)
 def eol(mctx, x):
 """File contains newlines of the given style (dos, unix, mac). Binary
 files are excluded, files with mixed line endings match multiple
 """
 # i18n: "eol" is a keyword
 enc = getstring(x, _("eol requires a style name"))
-s = []
+def eolp(fctx):
-for f in mctx.existing():
-fctx = mctx.ctx[f]
 if fctx.isbinary():
-continue
+return False
 d = fctx.data()
 if (enc == 'dos' or enc == 'win') and '\r\n' in d:
-s.append(f)
+return True
 elif enc == 'unix' and re.search('(?<!\r)\n', d):
-s.append(f)
+return True
 elif enc == 'mac' and re.search('\r(?!\n)', d):
-s.append(f)
+return True
-return s
+return False
+return mctx.fpredicate(eolp, predrepr=('eol(%r)', enc), cache=True)
 @predicate('copied()')
 def copied(mctx, x):
 """File that is recorded as being copied.
 """
 # i18n: "copied" is a keyword
 getargs(x, 0, 0, _("copied takes no arguments"))
-s = []
+def copiedp(fctx):
-for f in mctx.subset:
+p = fctx.parents()
-if f in mctx.ctx:
+return p and p[0].path() != fctx.path()
-p = mctx.ctx[f].parents()
+return mctx.fpredicate(copiedp, predrepr='copied', cache=True)
-if p and p[0].path() != f:
-s.append(f)
-return s
 @predicate('revs(revs, pattern)')
 def revs(mctx, x):
 """Evaluate set in the specified revisions. If the revset match multiple
 revs, this will return file matching pattern in any of the revision.
 # 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()
+matchers = []
-result = []
 for r in revs:
 ctx = repo[r]
-for f in getset(mctx.switch(ctx, _buildstatus(ctx, x)), x):
+matchers.append(getmatch(mctx.switch(ctx, _buildstatus(ctx, x)), x))
-if f not in found:
+if not matchers:
-found.add(f)
+return mctx.never()
-result.append(f)
+if len(matchers) == 1:
-return result
+return matchers[0]
+return matchmod.unionmatcher(matchers)
 @predicate('status(base, rev, pattern)')
 def status(mctx, x):
 """Evaluate predicate using status change between ``base`` and
 ``rev``. Examples:
 reverr = _("second argument to status must be a revision")
 revspec = getstring(r, reverr)
 if not revspec:
 raise error.ParseError(reverr)
 basectx, ctx = scmutil.revpair(repo, [baserevspec, revspec])
-return getset(mctx.switch(ctx, _buildstatus(ctx, x, basectx=basectx)), x)
+return getmatch(mctx.switch(ctx, _buildstatus(ctx, x, basectx=basectx)), x)
 @predicate('subrepo([pattern])')
 def subrepo(mctx, x):
 """Subrepositories whose paths match the given pattern.
 """
 # i18n: "subrepo" is a keyword
 getargs(x, 0, 1, _("subrepo takes at most one argument"))
 ctx = mctx.ctx
-sstate = sorted(ctx.substate)
+sstate = ctx.substate
 if x:
 pat = getpattern(x, matchmod.allpatternkinds,
 # i18n: "subrepo" is a keyword
 _("subrepo requires a pattern or no arguments"))
 fast = not matchmod.patkind(pat)
 if fast:
 def m(s):
 return (s == pat)
 else:
 m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx)
-return [sub for sub in sstate if m(sub)]
+return mctx.predicate(lambda f: f in sstate and m(f),
+predrepr=('subrepo(%r)', pat))
 else:
-return [sub for sub in sstate]
+return mctx.predicate(sstate.__contains__, predrepr='subrepo')
 methods = {
-'string': stringset,
+'string': stringmatch,
-'symbol': stringset,
+'symbol': stringmatch,
-'kindpat': kindpatset,
+'kindpat': kindpatmatch,
-'and': andset,
+'and': andmatch,
-'or': orset,
+'or': ormatch,
-'minus': minusset,
+'minus': minusmatch,
-'negate': negateset,
+'negate': negatematch,
-'list': listset,
+'list': listmatch,
-'group': getset,
+'group': getmatch,
-'not': notset,
+'not': notmatch,
 'func': func,
 }
 class matchctx(object):
 def __init__(self, ctx, subset, status=None, badfn=None):
 else:
 return list(ctx.walk(ctx.match([])))
 def match(ctx, expr, badfn=None):
 """Create a matcher for a single fileset expression"""
-repo = ctx.repo()
 tree = parse(expr)
-fset = getset(fullmatchctx(ctx, _buildstatus(ctx, tree), badfn=badfn), tree)
+mctx = fullmatchctx(ctx, _buildstatus(ctx, tree), badfn=badfn)
-return matchmod.predicatematcher(repo.root, repo.getcwd(),
+return getmatch(mctx, tree)
-fset.__contains__,
-predrepr='fileset', badfn=badfn)
 def _buildstatus(ctx, tree, basectx=None):
 # do we need status info?
 # temporaty boolean to simplify the next conditional

changeset 38689	ff5b6fca1082
parent 38687	1500cbe22d53
child 38690	5d9749c598f0