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

equal deleted inserted replaced

-:346af7687c6f
+:89a2afe31e82
 predicate = registrar.filesetpredicate(symbols)
 @predicate(b'modified()', callstatus=True, weight=_WEIGHT_STATUS)
 def modified(mctx, x):
-"""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, _(b"modified takes no arguments"))
 s = set(mctx.status().modified)
 return mctx.predicate(s.__contains__, predrepr=b'modified')
 @predicate(b'added()', callstatus=True, weight=_WEIGHT_STATUS)
 def added(mctx, x):
-"""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, _(b"added takes no arguments"))
 s = set(mctx.status().added)
 return mctx.predicate(s.__contains__, predrepr=b'added')
 @predicate(b'removed()', callstatus=True, weight=_WEIGHT_STATUS)
 def removed(mctx, x):
-"""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, _(b"removed takes no arguments"))
 s = set(mctx.status().removed)
 return mctx.predicate(s.__contains__, predrepr=b'removed')
 @predicate(b'deleted()', callstatus=True, weight=_WEIGHT_STATUS)
 def deleted(mctx, x):
-"""Alias for ``missing()``.
+"""Alias for ``missing()``."""
-"""
 # i18n: "deleted" is a keyword
 getargs(x, 0, 0, _(b"deleted takes no arguments"))
 s = set(mctx.status().deleted)
 return mctx.predicate(s.__contains__, predrepr=b'deleted')
 @predicate(b'missing()', callstatus=True, weight=_WEIGHT_STATUS)
 def missing(mctx, x):
-"""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, _(b"missing takes no arguments"))
 s = set(mctx.status().deleted)
 return mctx.predicate(s.__contains__, predrepr=b'deleted')
 return mctx.predicate(s.__contains__, predrepr=b'ignored')
 @predicate(b'clean()', callstatus=True, weight=_WEIGHT_STATUS)
 def clean(mctx, x):
-"""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, _(b"clean takes no arguments"))
 s = set(mctx.status().clean)
 return mctx.predicate(s.__contains__, predrepr=b'clean')
 return mctx.predicate(mctx.ctx.__contains__, predrepr=b'tracked')
 @predicate(b'binary()', weight=_WEIGHT_READ_CONTENTS)
 def binary(mctx, x):
-"""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, _(b"binary takes no arguments"))
 return mctx.fpredicate(
 lambda fctx: fctx.isbinary(), predrepr=b'binary', cache=True
 )
 @predicate(b'exec()')
 def exec_(mctx, x):
-"""File that is marked as executable.
+"""File that is marked as executable."""
-"""
 # i18n: "exec" is a keyword
 getargs(x, 0, 0, _(b"exec takes no arguments"))
 ctx = mctx.ctx
 return mctx.predicate(lambda f: ctx.flags(f) == b'x', predrepr=b'exec')
 @predicate(b'symlink()')
 def symlink(mctx, x):
-"""File that is marked as a symlink.
+"""File that is marked as a symlink."""
-"""
 # i18n: "symlink" is a keyword
 getargs(x, 0, 0, _(b"symlink takes no arguments"))
 ctx = mctx.ctx
 return mctx.predicate(lambda f: ctx.flags(f) == b'l', predrepr=b'symlink')
 @predicate(b'resolved()', weight=_WEIGHT_STATUS)
 def resolved(mctx, x):
-"""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, _(b"resolved takes no arguments"))
 if mctx.ctx.rev() is not None:
 return mctx.never()
 ms = mergestatemod.mergestate.read(mctx.ctx.repo())
 )
 @predicate(b'unresolved()', weight=_WEIGHT_STATUS)
 def unresolved(mctx, x):
-"""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, _(b"unresolved takes no arguments"))
 if mctx.ctx.rev() is not None:
 return mctx.never()
 ms = mergestatemod.mergestate.read(mctx.ctx.repo())
 )
 @predicate(b'hgignore()', weight=_WEIGHT_STATUS)
 def hgignore(mctx, x):
-"""File that matches the active .hgignore pattern.
+"""File that matches the active .hgignore pattern."""
-"""
 # i18n: "hgignore" is a keyword
 getargs(x, 0, 0, _(b"hgignore takes no arguments"))
 return mctx.ctx.repo().dirstate._ignore
 )
 @predicate(b'grep(regex)', weight=_WEIGHT_READ_CONTENTS)
 def grep(mctx, x):
-"""File contains the given regular expression.
+"""File contains the given regular expression."""
-"""
 try:
 # i18n: "grep" is a keyword
 r = re.compile(getstring(x, _(b"grep requires a pattern")))
 except re.error as e:
 raise error.ParseError(
 return mctx.fpredicate(eolp, predrepr=(b'eol(%r)', enc), cache=True)
 @predicate(b'copied()')
 def copied(mctx, x):
-"""File that is recorded as being copied.
+"""File that is recorded as being copied."""
-"""
 # i18n: "copied" is a keyword
 getargs(x, 0, 0, _(b"copied takes no arguments"))
 def copiedp(fctx):
 p = fctx.parents()
 return getmatch(mc, x)
 @predicate(b'subrepo([pattern])')
 def subrepo(mctx, x):
-"""Subrepositories whose paths match the given pattern.
+"""Subrepositories whose paths match the given pattern."""
-"""
 # i18n: "subrepo" is a keyword
 getargs(x, 0, 1, _(b"subrepo takes at most one argument"))
 ctx = mctx.ctx
 sstate = ctx.substate
 if x:
 mctx = matchctx(ctx.p1(), ctx, cwd, badfn=badfn)
 return getmatch(mctx, tree)
 def loadpredicate(ui, extname, registrarobj):
-"""Load fileset predicates from specified registrarobj
+"""Load fileset predicates from specified registrarobj"""
-"""
 for name, func in pycompat.iteritems(registrarobj._table):
 symbols[name] = func
 # tell hggettext to extract docstrings from these functions:

changeset 45942	89a2afe31e82
parent 44856	b7808443ed6a
child 46819	d4ba4d51f85f