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

comparison mercurial/fileset.py @ 27460:11286ac374f3

fileset: use decorator to mark a function as fileset predicate Using decorator can localize changes for adding (or removing) a fileset predicate function in source code. It is also useful to pick predicates up for specific purpose. For example, subsequent patches marks predicates as "call status" or "use existing" via decorator. To avoid (1) redundancy between "predicate name" and (the beginning of) help document, and (2) accidental typo of help document, this patch also makes decorator put predicate declration into the beginning of help.

author	FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
date	Mon, 21 Dec 2015 22:31:16 +0900
parents	2f15253e415f
children	afa76585c955

comparison

equal deleted inserted replaced

-:2f15253e415f
+:11286ac374f3
 return [f for f in xl if f not in yl]
 def listset(mctx, a, b):
 raise error.ParseError(_("can't use a list in this context"))
+# symbols are callable like:
+#  fun(mctx, x)
+# with:
+#  mctx - current matchctx instance
+#  x - argument in tree form
+symbols = {}
+def predicate(decl):
+"""Return a decorator for fileset predicate function
+'decl' argument is the declaration (including argument list like
+'adds(pattern)') or the name (for internal use only) of predicate.
+"""
+def decorator(func):
+i = decl.find('(')
+if i > 0:
+name = decl[:i]
+else:
+name = decl
+symbols[name] = func
+if func.__doc__:
+func.__doc__ = "``%s``\n    %s" % (decl, func.__doc__.strip())
+return func
+return decorator
+@predicate('modified()')
 def modified(mctx, x):
-"""``modified()``
+"""File that is modified according to :hg:`status`.
-File that is modified according to :hg:`status`.
 """
 # i18n: "modified" is a keyword
 getargs(x, 0, 0, _("modified takes no arguments"))
 s = mctx.status().modified
 return [f for f in mctx.subset if f in s]
+@predicate('added()')
 def added(mctx, x):
-"""``added()``
+"""File that is added according to :hg:`status`.
-File that is added according to :hg:`status`.
 """
 # i18n: "added" is a keyword
 getargs(x, 0, 0, _("added takes no arguments"))
 s = mctx.status().added
 return [f for f in mctx.subset if f in s]
+@predicate('removed()')
 def removed(mctx, x):
-"""``removed()``
+"""File that is removed according to :hg:`status`.
-File that is removed according to :hg:`status`.
 """
 # i18n: "removed" is a keyword
 getargs(x, 0, 0, _("removed takes no arguments"))
 s = mctx.status().removed
 return [f for f in mctx.subset if f in s]
+@predicate('deleted()')
 def deleted(mctx, x):
-"""``deleted()``
+"""Alias for ``missing()``.
-Alias for ``missing()``.
 """
 # i18n: "deleted" is a keyword
 getargs(x, 0, 0, _("deleted takes no arguments"))
 s = mctx.status().deleted
 return [f for f in mctx.subset if f in s]
+@predicate('missing()')
 def missing(mctx, x):
-"""``missing()``
+"""File that is missing according to :hg:`status`.
-File that is missing according to :hg:`status`.
 """
 # i18n: "missing" is a keyword
 getargs(x, 0, 0, _("missing takes no arguments"))
 s = mctx.status().deleted
 return [f for f in mctx.subset if f in s]
+@predicate('unknown()')
 def unknown(mctx, x):
-"""``unknown()``
+"""File that is unknown according to :hg:`status`. These files will only be
-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 = mctx.status().unknown
 return [f for f in mctx.subset if f in s]
+@predicate('ignored()')
 def ignored(mctx, x):
-"""``ignored()``
+"""File that is ignored according to :hg:`status`. These files will only be
-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 = mctx.status().ignored
 return [f for f in mctx.subset if f in s]
+@predicate('clean()')
 def clean(mctx, x):
-"""``clean()``
+"""File that is clean according to :hg:`status`.
-File that is clean according to :hg:`status`.
 """
 # i18n: "clean" is a keyword
 getargs(x, 0, 0, _("clean takes no arguments"))
 s = mctx.status().clean
 return [f for f in mctx.subset if f in s]
 l = getlist(x)
 if len(l) < min or len(l) > max:
 raise error.ParseError(err)
 return l
+@predicate('binary()')
 def binary(mctx, x):
-"""``binary()``
+"""File that appears to be binary (contains NUL bytes).
-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 util.binary(mctx.ctx[f].data())]
+@predicate('exec()')
 def exec_(mctx, x):
-"""``exec()``
+"""File that is marked as executable.
-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()')
 def symlink(mctx, x):
-"""``symlink()``
+"""File that is marked as a symlink.
-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):
-"""``resolved()``
+"""File that is marked resolved according to :hg:`resolve -l`.
-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):
-"""``unresolved()``
+"""File that is marked unresolved according to :hg:`resolve -l`.
-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):
-"""``hgignore()``
+"""File that matches the active .hgignore pattern.
-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):
-"""``portable()``
+"""File that has a portable name. (This doesn't include filenames with case
-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)')
 def grep(mctx, x):
-"""``grep(regex)``
+"""File contains the given regular expression.
-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:
 # no extension, this is a precise value
 return int(s)
 except ValueError:
 raise error.ParseError(_("couldn't parse size: %s") % s)
+@predicate('size(expression)')
 def size(mctx, x):
-"""``size(expression)``
+"""File size matches the given expression. Examples:
-File size matches the given expression. Examples:
 - 1k (files from 1024 to 2047 bytes)
 - < 20k (files less than 20480 bytes)
 - >= .5MB (files at least 524288 bytes)
 - 4k - 1MB (files from 4096 bytes to 1048576 bytes)
 else:
 raise error.ParseError(_("couldn't parse size: %s") % expr)
 return [f for f in mctx.existing() if m(mctx.ctx[f].size())]
+@predicate('encoding(name)')
 def encoding(mctx, x):
-"""``encoding(name)``
+"""File can be successfully decoded with the given character
-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
 continue
 s.append(f)
 return s
+@predicate('eol(style)')
 def eol(mctx, x):
-"""``eol(style)``
+"""File contains newlines of the given style (dos, unix, mac). Binary
-File contains newlines of the given style (dos, unix, mac). Binary
 files are excluded, files with mixed line endings match multiple
 styles.
 """
 # i18n: "encoding" is a keyword
 s.append(f)
 elif enc == 'mac' and re.search('\r(?!\n)', d):
 s.append(f)
 return s
+@predicate('copied()')
 def copied(mctx, x):
-"""``copied()``
+"""File that is recorded as being copied.
-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('subrepo([pattern])')
 def subrepo(mctx, x):
-"""``subrepo([pattern])``
+"""Subrepositories whose paths match the given pattern.
-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)
 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]
-symbols = {
-'added': added,
-'binary': binary,
-'clean': clean,
-'copied': copied,
-'deleted': deleted,
-'encoding': encoding,
-'eol': eol,
-'exec': exec_,
-'grep': grep,
-'ignored': ignored,
-'hgignore': hgignore,
-'missing': missing,
-'modified': modified,
-'portable': portable,
-'removed': removed,
-'resolved': resolved,
-'size': size,
-'symlink': symlink,
-'unknown': unknown,
-'unresolved': unresolved,
-'subrepo': subrepo,
-}
 methods = {
 'string': stringset,
 'symbol': stringset,
 'and': andset,

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/fileset.py @ 27460:11286ac374f3