fileset: do not crash by unary negate operation

Backported from minifileset.py.

mercurial/fileset.py

@@ -1,639 +1,643
 # fileset.py - file set queries for mercurial
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 from . import (
     error,
     merge,
     parser,
     pycompat,
     registrar,
     scmutil,
     util,
 )
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
     "-": (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),
 }
 
 keywords = {'and', 'or', 'not'}
 
 globchars = ".*{}[]?/\\_"
 
 def tokenize(program):
     pos, l = 0, len(program)
     program = pycompat.bytestr(program)
     while pos < l:
         c = program[pos]
         if c.isspace(): # skip inter-token whitespace
             pass
         elif c in "(),-|&+!": # handle simple operators
             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:
                 decode = parser.unescapestr
             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)
         elif c.isalnum() or c in globchars or ord(c) > 127:
             # gather up a symbol/keyword
             s = pos
             pos += 1
             while pos < l: # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d in globchars or ord(d) > 127):
                     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)
 
 def parse(expr):
     p = parser.parser(elements)
     tree, pos = p.parse(tokenize(expr))
     if pos != len(expr):
         raise error.ParseError(_("invalid token"), pos)
     return tree
 
 def getsymbol(x):
     if x and x[0] == 'symbol':
         return x[1]
     raise error.ParseError(_('not a symbol'))
 
 def getstring(x, err):
     if x and (x[0] == 'string' or x[0] == 'symbol'):
         return x[1]
     raise error.ParseError(err)
 
 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)]
 
 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]
 
 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]
 
+def negateset(mctx, x):
+    raise error.ParseError(_("can't use negate operator in this context"))
+
 def listset(mctx, a, b):
     raise error.ParseError(_("can't use a list in this context"),
                            hint=_('see hg help "filesets.x or y"'))
 
 # symbols are callable like:
 #  fun(mctx, x)
 # with:
 #  mctx - current matchctx instance
 #  x - argument in tree form
 symbols = {}
 
 # filesets using matchctx.status()
 _statuscallers = set()
 
 # filesets using matchctx.existing()
 _existingcallers = set()
 
 predicate = registrar.filesetpredicate()
 
 @predicate('modified()', callstatus=True)
 def modified(mctx, x):
     """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]
 
 @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]
 
 @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]
 
 @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]
 
 @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]
 
 @predicate('unknown()', callstatus=True)
 def unknown(mctx, x):
     """File that is unknown according to :hg:`status`. These files will only be
     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]
 
 @predicate('ignored()', callstatus=True)
 def ignored(mctx, x):
     """File that is ignored according to :hg:`status`. These files will only be
     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]
 
 @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]
 
 def func(mctx, a, b):
     funcname = getsymbol(a)
     if funcname in symbols:
         enabled = mctx._existingenabled
         mctx._existingenabled = funcname in _existingcallers
         try:
             return symbols[funcname](mctx, b)
         finally:
             mctx._existingenabled = enabled
 
     keep = lambda fn: getattr(fn, '__doc__', None) is not None
 
     syms = [s for (s, fn) in symbols.items() if keep(fn)]
     raise error.UnknownIdentifier(funcname, syms)
 
 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
 
 @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()]
 
 @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']
 
 @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']
 
 @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 []
     ms = merge.mergestate.read(mctx.ctx.repo())
     return [f for f in mctx.subset if f in ms and ms[f] == 'r']
 
 @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 []
     ms = merge.mergestate.read(mctx.ctx.repo())
     return [f for f in mctx.subset if f in ms and ms[f] == 'u']
 
 @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 [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 [f for f in mctx.subset if checkwinfilename(f) is None]
 
 @predicate('grep(regex)', callexisting=True)
 def grep(mctx, x):
     """File contains the given regular expression.
     """
     try:
         # 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') % e)
     return [f for f in mctx.existing() if r.search(mctx.ctx[f].data())]
 
 def _sizetomax(s):
     try:
         s = s.strip().lower()
         for k, v in util._sizeunits:
             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:
         raise error.ParseError(_("couldn't parse size: %s") % s)
 
 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
     elif expr[0].isdigit or expr[0] == '.':
         a = util.sizetoint(expr)
         b = _sizetomax(expr)
         return lambda x: x >= a and x <= b
     raise error.ParseError(_("couldn't parse size: %s") % expr)
 
 @predicate('size(expression)', callexisting=True)
 def size(mctx, x):
     """File size matches the given expression. Examples:
 
     - 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
     """
     m = sizematcher(x)
     return [f for f in mctx.existing() if m(mctx.ctx[f].size())]
 
 @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
     UTF-8.
     """
 
     # i18n: "encoding" is a keyword
     enc = getstring(x, _("encoding requires an encoding name"))
 
     s = []
     for f in mctx.existing():
         d = mctx.ctx[f].data()
         try:
             d.decode(enc)
         except LookupError:
             raise error.Abort(_("unknown encoding '%s'") % enc)
         except UnicodeDecodeError:
             continue
         s.append(f)
 
     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
     styles.
     """
 
     # i18n: "eol" is a keyword
     enc = getstring(x, _("eol requires a style name"))
 
     s = []
     for f in mctx.existing():
         d = mctx.ctx[f].data()
         if util.binary(d):
             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
 
 @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 = []
     for f in mctx.subset:
         p = mctx.ctx[f].parents()
         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
     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
 
 @predicate('status(base, rev, pattern)')
 def status(mctx, x):
     """Evaluate predicate using status change between ``base`` and
     ``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)
     basenode, node = scmutil.revpair(repo, [baserevspec, revspec])
     basectx = repo[basenode]
     ctx = repo[node]
     return getset(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)
     if x:
         # i18n: "subrepo" is a keyword
         pat = getstring(x, _("subrepo requires a pattern or no arguments"))
 
         from . import match as matchmod # avoid circular import issues
         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)]
     else:
         return [sub for sub in sstate]
 
 methods = {
     'string': stringset,
     'symbol': stringset,
     'and': andset,
     'or': orset,
     'minus': minusset,
+    'negate': negateset,
     'list': listset,
     'group': getset,
     'not': notset,
     'func': func,
 }
 
 class matchctx(object):
     def __init__(self, ctx, subset, status=None):
         self.ctx = ctx
         self.subset = subset
         self._status = status
         self._existingenabled = False
     def status(self):
         return self._status
     def matcher(self, patterns):
         return self.ctx.match(patterns)
     def filter(self, files):
         return [f for f in files if f in self.subset]
     def existing(self):
         assert self._existingenabled, 'unexpected existing() invocation'
         if self._status is not None:
             removed = set(self._status[3])
             unknown = set(self._status[4] + self._status[5])
         else:
             removed = set()
             unknown = set()
         return (f for f in self.subset
                 if (f in self.ctx and f not in removed) or f in unknown)
     def narrow(self, files):
         return matchctx(self.ctx, self.filter(files), self._status)
     def switch(self, ctx, status=None):
         subset = self.filter(_buildsubset(ctx, status))
         return matchctx(ctx, subset, status)
 
 class fullmatchctx(matchctx):
     """A match context where any files in any revisions should be valid"""
 
     def __init__(self, ctx, status=None):
         subset = _buildsubset(ctx, status)
         super(fullmatchctx, self).__init__(ctx, subset, status)
     def switch(self, ctx, status=None):
         return fullmatchctx(ctx, status)
 
 # filesets using matchctx.switch()
 _switchcallers = [
     'revs',
     'status',
 ]
 
 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
             if tree[1][1] in _switchcallers:
                 # arguments won't be evaluated in the current context
                 return False
         for s in tree[1:]:
             if _intree(funcs, s):
                 return True
     return False
 
 def _buildsubset(ctx, status):
     if status:
         subset = []
         for c in status:
             subset.extend(c)
         return subset
     else:
         return list(ctx.walk(ctx.match([])))
 
 def getfileset(ctx, expr):
     tree = parse(expr)
     return getset(fullmatchctx(ctx, _buildstatus(ctx, tree)), tree)
 
 def _buildstatus(ctx, tree, basectx=None):
     # do we need status info?
 
     # temporaty boolean to simplify the next conditional
     purewdir = ctx.rev() is None and basectx is None
 
     if (_intree(_statuscallers, tree) or
         # Using matchctx.existing() on a workingctx requires us to check
         # for deleted files.
         (purewdir and _intree(_existingcallers, tree))):
         unknown = _intree(['unknown'], tree)
         ignored = _intree(['ignored'], tree)
 
         r = ctx.repo()
         if basectx is None:
             basectx = ctx.p1()
         return r.status(basectx, ctx,
                         unknown=unknown, ignored=ignored, clean=True)
     else:
         return None
 
 def prettyformat(tree):
     return parser.prettyformat(tree, ('string', 'symbol'))
 
 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)
 
 # load built-in predicates explicitly to setup _statuscallers/_existingcallers
 loadpredicate(None, None, predicate)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = symbols.values()

tests/test-fileset.t

@@ -1,622 +1,633
   $ fileset() {
   >   hg debugfileset "$@"
   > }
 
   $ hg init repo
   $ cd repo
   $ echo a > a1
   $ echo a > a2
   $ echo b > b1
   $ echo b > b2
   $ hg ci -Am addfiles
   adding a1
   adding a2
   adding b1
   adding b2
 
 Test operators and basic patterns
 
   $ fileset -v a1
   (symbol 'a1')
   a1
   $ fileset -v 'a*'
   (symbol 'a*')
   a1
   a2
   $ fileset -v '"re:a\d"'
   (string 're:a\\d')
   a1
   a2
   $ fileset -v 'a1 or a2'
   (or
     (symbol 'a1')
     (symbol 'a2'))
   a1
   a2
   $ fileset 'a1 | a2'
   a1
   a2
   $ fileset 'a* and "*1"'
   a1
   $ fileset 'a* & "*1"'
   a1
   $ fileset 'not (r"a*")'
   b1
   b2
   $ fileset '! ("a*")'
   b1
   b2
   $ fileset 'a* - a1'
   a2
   $ fileset 'a_b'
   $ fileset '"\xy"'
   hg: parse error: invalid \x escape
   [255]
 
 Test invalid syntax
 
   $ fileset -v '"added"()'
   (func
     (string 'added')
     None)
   hg: parse error: not a symbol
   [255]
   $ fileset -v '()()'
   (func
     (group
       None)
     None)
   hg: parse error: not a symbol
   [255]
+  $ fileset -v -- '-x'
+  (negate
+    (symbol 'x'))
+  hg: parse error: can't use negate operator in this context
+  [255]
+  $ fileset -v -- '-()'
+  (negate
+    (group
+      None))
+  hg: parse error: can't use negate operator in this context
+  [255]
 
 Test files status
 
   $ rm a1
   $ hg rm a2
   $ echo b >> b2
   $ hg cp b1 c1
   $ echo c > c2
   $ echo c > c3
   $ cat > .hgignore <<EOF
   > \.hgignore
   > 2$
   > EOF
   $ fileset 'modified()'
   b2
   $ fileset 'added()'
   c1
   $ fileset 'removed()'
   a2
   $ fileset 'deleted()'
   a1
   $ fileset 'missing()'
   a1
   $ fileset 'unknown()'
   c3
   $ fileset 'ignored()'
   .hgignore
   c2
   $ fileset 'hgignore()'
   a2
   b2
   $ fileset 'clean()'
   b1
   $ fileset 'copied()'
   c1
 
 Test files status in different revisions
 
   $ hg status -m
   M b2
   $ fileset -r0 'revs("wdir()", modified())' --traceback
   b2
   $ hg status -a
   A c1
   $ fileset -r0 'revs("wdir()", added())'
   c1
   $ hg status --change 0 -a
   A a1
   A a2
   A b1
   A b2
   $ hg status -mru
   M b2
   R a2
   ? c3
   $ fileset -r0 'added() and revs("wdir()", modified() or removed() or unknown())'
   b2
   a2
   $ fileset -r0 'added() or revs("wdir()", added())'
   a1
   a2
   b1
   b2
   c1
 
 Test files properties
 
   >>> file('bin', 'wb').write('\0a')
   $ fileset 'binary()'
   $ fileset 'binary() and unknown()'
   bin
   $ echo '^bin$' >> .hgignore
   $ fileset 'binary() and ignored()'
   bin
   $ hg add bin
   $ fileset 'binary()'
   bin
 
   $ fileset 'grep("b{1}")'
   b2
   c1
   b1
   $ fileset 'grep("missingparens(")'
   hg: parse error: invalid match pattern: unbalanced parenthesis
   [255]
 
 #if execbit
   $ chmod +x b2
   $ fileset 'exec()'
   b2
 #endif
 
 #if symlink
   $ ln -s b2 b2link
   $ fileset 'symlink() and unknown()'
   b2link
   $ hg add b2link
 #endif
 
 #if no-windows
   $ echo foo > con.xml
   $ fileset 'not portable()'
   con.xml
   $ hg --config ui.portablefilenames=ignore add con.xml
 #endif
 
   >>> file('1k', 'wb').write(' '*1024)
   >>> file('2k', 'wb').write(' '*2048)
   $ hg add 1k 2k
   $ fileset 'size("bar")'
   hg: parse error: couldn't parse size: bar
   [255]
   $ fileset '(1k, 2k)'
   hg: parse error: can't use a list in this context
   (see hg help "filesets.x or y")
   [255]
   $ fileset 'size(1k)'
   1k
   $ fileset '(1k or 2k) and size("< 2k")'
   1k
   $ fileset '(1k or 2k) and size("<=2k")'
   1k
   2k
   $ fileset '(1k or 2k) and size("> 1k")'
   2k
   $ fileset '(1k or 2k) and size(">=1K")'
   1k
   2k
   $ fileset '(1k or 2k) and size(".5KB - 1.5kB")'
   1k
   $ fileset 'size("1M")'
   $ fileset 'size("1 GB")'
 
 Test merge states
 
   $ hg ci -m manychanges
   $ hg up -C 0
   * files updated, 0 files merged, * files removed, 0 files unresolved (glob)
   $ echo c >> b2
   $ hg ci -m diverging b2
   created new head
   $ fileset 'resolved()'
   $ fileset 'unresolved()'
   $ hg merge
   merging b2
   warning: conflicts while merging b2! (edit, then use 'hg resolve --mark')
   * files updated, 0 files merged, 1 files removed, 1 files unresolved (glob)
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ fileset 'resolved()'
   $ fileset 'unresolved()'
   b2
   $ echo e > b2
   $ hg resolve -m b2
   (no more unresolved files)
   $ fileset 'resolved()'
   b2
   $ fileset 'unresolved()'
   $ hg ci -m merge
 
 Test subrepo predicate
 
   $ hg init sub
   $ echo a > sub/suba
   $ hg -R sub add sub/suba
   $ hg -R sub ci -m sub
   $ echo 'sub = sub' > .hgsub
   $ hg init sub2
   $ echo b > sub2/b
   $ hg -R sub2 ci -Am sub2
   adding b
   $ echo 'sub2 = sub2' >> .hgsub
   $ fileset 'subrepo()'
   $ hg add .hgsub
   $ fileset 'subrepo()'
   sub
   sub2
   $ fileset 'subrepo("sub")'
   sub
   $ fileset 'subrepo("glob:*")'
   sub
   sub2
   $ hg ci -m subrepo
 
 Test that .hgsubstate is updated as appropriate during a conversion.  The
 saverev property is enough to alter the hashes of the subrepo.
 
   $ hg init ../converted
   $ hg --config extensions.convert= convert --config convert.hg.saverev=True  \
   >      sub ../converted/sub
   initializing destination ../converted/sub repository
   scanning source...
   sorting...
   converting...
   0 sub
   $ hg clone -U sub2 ../converted/sub2
   $ hg --config extensions.convert= convert --config convert.hg.saverev=True  \
   >      . ../converted
   scanning source...
   sorting...
   converting...
   4 addfiles
   3 manychanges
   2 diverging
   1 merge
   0 subrepo
   no ".hgsubstate" updates will be made for "sub2"
   $ hg up -q -R ../converted -r tip
   $ hg --cwd ../converted cat sub/suba sub2/b -r tip
   a
   b
   $ oldnode=`hg log -r tip -T "{node}\n"`
   $ newnode=`hg log -R ../converted -r tip -T "{node}\n"`
   $ [ "$oldnode" != "$newnode" ] || echo "nothing changed"
 
 Test with a revision
 
   $ hg log -G --template '{rev} {desc}\n'
   @  4 subrepo
   |
   o    3 merge
   |\
   | o  2 diverging
   | |
   o |  1 manychanges
   |/
   o  0 addfiles
   
   $ echo unknown > unknown
   $ fileset -r1 'modified()'
   b2
   $ fileset -r1 'added() and c1'
   c1
   $ fileset -r1 'removed()'
   a2
   $ fileset -r1 'deleted()'
   $ fileset -r1 'unknown()'
   $ fileset -r1 'ignored()'
   $ fileset -r1 'hgignore()'
   b2
   bin
   $ fileset -r1 'binary()'
   bin
   $ fileset -r1 'size(1k)'
   1k
   $ fileset -r3 'resolved()'
   $ fileset -r3 'unresolved()'
 
 #if execbit
   $ fileset -r1 'exec()'
   b2
 #endif
 
 #if symlink
   $ fileset -r1 'symlink()'
   b2link
 #endif
 
 #if no-windows
   $ fileset -r1 'not portable()'
   con.xml
   $ hg forget 'con.xml'
 #endif
 
   $ fileset -r4 'subrepo("re:su.*")'
   sub
   sub2
   $ fileset -r4 'subrepo("sub")'
   sub
   $ fileset -r4 'b2 or c1'
   b2
   c1
 
   >>> open('dos', 'wb').write("dos\r\n")
   >>> open('mixed', 'wb').write("dos\r\nunix\n")
   >>> open('mac', 'wb').write("mac\r")
   $ hg add dos mixed mac
 
 (remove a1, to examine safety of 'eol' on removed files)
   $ rm a1
 
   $ fileset 'eol(dos)'
   dos
   mixed
   $ fileset 'eol(unix)'
   mixed
   .hgsub
   .hgsubstate
   b1
   b2
   c1
   $ fileset 'eol(mac)'
   mac
 
 Test safety of 'encoding' on removed files
 
   $ fileset 'encoding("ascii")'
   dos
   mac
   mixed
   .hgsub
   .hgsubstate
   1k
   2k
   b1
   b2
   b2link (symlink !)
   bin
   c1
 
 Test detection of unintentional 'matchctx.existing()' invocation
 
   $ cat > $TESTTMP/existingcaller.py <<EOF
   > from mercurial import registrar
   > 
   > filesetpredicate = registrar.filesetpredicate()
   > @filesetpredicate('existingcaller()', callexisting=False)
   > def existingcaller(mctx, x):
   >     # this 'mctx.existing()' invocation is unintentional
   >     return [f for f in mctx.existing()]
   > EOF
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > existingcaller = $TESTTMP/existingcaller.py
   > EOF
 
   $ fileset 'existingcaller()' 2>&1 | tail -1
   AssertionError: unexpected existing() invocation
 
 Test 'revs(...)'
 ================
 
 small reminder of the repository state
 
   $ hg log -G
   @  changeset:   4:* (glob)
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     subrepo
   |
   o    changeset:   3:* (glob)
   |\   parent:      2:55b05bdebf36
   | |  parent:      1:* (glob)
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     merge
   | |
   | o  changeset:   2:55b05bdebf36
   | |  parent:      0:8a9576c51c1f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     diverging
   | |
   o |  changeset:   1:* (glob)
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     manychanges
   |
   o  changeset:   0:8a9576c51c1f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     addfiles
   
   $ hg status --change 0
   A a1
   A a2
   A b1
   A b2
   $ hg status --change 1
   M b2
   A 1k
   A 2k
   A b2link (no-windows !)
   A bin
   A c1
   A con.xml (no-windows !)
   R a2
   $ hg status --change 2
   M b2
   $ hg status --change 3
   M b2
   A 1k
   A 2k
   A b2link (no-windows !)
   A bin
   A c1
   A con.xml (no-windows !)
   R a2
   $ hg status --change 4
   A .hgsub
   A .hgsubstate
   $ hg status
   A dos
   A mac
   A mixed
   R con.xml (no-windows !)
   ! a1
   ? b2.orig
   ? c3
   ? unknown
 
 Test files at -r0 should be filtered by files at wdir
 -----------------------------------------------------
 
   $ fileset -r0 '* and revs("wdir()", *)'
   a1
   b1
   b2
 
 Test that "revs()" work at all
 ------------------------------
 
   $ fileset "revs('2', modified())"
   b2
 
 Test that "revs()" work for file missing in the working copy/current context
 ----------------------------------------------------------------------------
 
 (a2 not in working copy)
 
   $ fileset "revs('0', added())"
   a1
   a2
   b1
   b2
 
 (none of the file exist in "0")
 
   $ fileset -r 0 "revs('4', added())"
   .hgsub
   .hgsubstate
 
 Call with empty revset
 --------------------------
 
   $ fileset "revs('2-2', modified())"
 
 Call with revset matching multiple revs
 ---------------------------------------
 
   $ fileset "revs('0+4', added())"
   a1
   a2
   b1
   b2
   .hgsub
   .hgsubstate
 
 overlapping set
 
   $ fileset "revs('1+2', modified())"
   b2
 
 test 'status(...)'
 =================
 
 Simple case
 -----------
 
   $ fileset "status(3, 4, added())"
   .hgsub
   .hgsubstate
 
 use rev to restrict matched file
 -----------------------------------------
 
   $ hg status --removed --rev 0 --rev 1
   R a2
   $ fileset "status(0, 1, removed())"
   a2
   $ fileset "* and status(0, 1, removed())"
   $ fileset -r 4 "status(0, 1, removed())"
   a2
   $ fileset -r 4 "* and status(0, 1, removed())"
   $ fileset "revs('4', * and status(0, 1, removed()))"
   $ fileset "revs('0', * and status(0, 1, removed()))"
   a2
 
 check wdir()
 ------------
 
   $ hg status --removed  --rev 4
   R con.xml (no-windows !)
   $ fileset "status(4, 'wdir()', removed())"
   con.xml (no-windows !)
 
   $ hg status --removed --rev 2
   R a2
   $ fileset "status('2', 'wdir()', removed())"
   a2
 
 test backward status
 --------------------
 
   $ hg status --removed --rev 0 --rev 4
   R a2
   $ hg status --added --rev 4 --rev 0
   A a2
   $ fileset "status(4, 0, added())"
   a2
 
 test cross branch status
 ------------------------
 
   $ hg status --added --rev 1 --rev 2
   A a2
   $ fileset "status(1, 2, added())"
   a2
 
 test with multi revs revset
 ---------------------------
   $ hg status --added --rev 0:1 --rev 3:4
   A .hgsub
   A .hgsubstate
   A 1k
   A 2k
   A b2link (no-windows !)
   A bin
   A c1
   A con.xml (no-windows !)
   $ fileset "status('0:1', '3:4', added())"
   .hgsub
   .hgsubstate
   1k
   2k
   b2link (no-windows !)
   bin
   c1
   con.xml (no-windows !)
 
 tests with empty value
 ----------------------
 
 Fully empty revset
 
   $ fileset "status('', '4', added())"
   hg: parse error: first argument to status must be a revision
   [255]
   $ fileset "status('2', '', added())"
   hg: parse error: second argument to status must be a revision
   [255]
 
 Empty revset will error at the revset layer
 
   $ fileset "status(' ', '4', added())"
   hg: parse error at 1: not a prefix: end
   [255]
   $ fileset "status('2', ' ', added())"
   hg: parse error at 1: not a prefix: end
   [255]