Mercurial > hg
annotate mercurial/templatefuncs.py @ 37680:e743b8524d60
scmutil: introduce shortesthexnodeidprefix()
We have scmutil.resolvehexnodeidprefix() for resolving a prefix to a
full nodeid, so it makes sense to have the inverse method next to
it. For now it just delegates to changelog.shortest(), but it will
soon also make sure it's called on the unfiltered repo, to match
resolvehexnodeidprefix().
Note that the change in show.py also makes it so the conversion from
revnum to nodeid is done on the filtered repo, but that should be
inconsequential since the revs are all from the filtered repo anyway.
Differential Revision: https://phab.mercurial-scm.org/D3370
author | Martin von Zweigbergk <martinvonz@google.com> |
---|---|
date | Fri, 13 Apr 2018 22:55:01 -0700 |
parents | f83cb91b052e |
children | 8e8541610d85 |
rev | line source |
---|---|
36922
521f6c7e1756
templater: split template functions to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36921
diff
changeset
|
1 # templatefuncs.py - common template functions |
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
2 # |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
3 # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
4 # |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
8223
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
7 |
36922
521f6c7e1756
templater: split template functions to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36921
diff
changeset
|
8 from __future__ import absolute_import |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
9 |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
10 import re |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
11 |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
12 from .i18n import _ |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
13 from . import ( |
31521
44c591f63458
templater: make pad() strip color codes before computing width (issue5416)
Yuya Nishihara <yuya@tcha.org>
parents:
31520
diff
changeset
|
14 color, |
31520
6f150bb19317
templater: make pad() compute actual width
Yuya Nishihara <yuya@tcha.org>
parents:
31519
diff
changeset
|
15 encoding, |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
16 error, |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
17 minirst, |
33993
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
18 obsutil, |
30615
bb77654dc7ae
py3: replace os.sep with pycompat.ossep (part 3 of 4)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30332
diff
changeset
|
19 pycompat, |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
20 registrar, |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
21 revset as revsetmod, |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30625
diff
changeset
|
22 revsetlang, |
34458
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
23 scmutil, |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
24 templatefilters, |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
25 templatekw, |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
26 templateutil, |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
27 util, |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
28 ) |
37210
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
29 from .utils import ( |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
30 dateutil, |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
31 stringutil, |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
32 ) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
33 |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
34 evalrawexp = templateutil.evalrawexp |
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
35 evalfuncarg = templateutil.evalfuncarg |
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
36 evalboolean = templateutil.evalboolean |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37210
diff
changeset
|
37 evaldate = templateutil.evaldate |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
38 evalinteger = templateutil.evalinteger |
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
39 evalstring = templateutil.evalstring |
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
40 evalstringliteral = templateutil.evalstringliteral |
36443
8dbd97aef915
templater: move specialized exception types to top
Yuya Nishihara <yuya@tcha.org>
parents:
36245
diff
changeset
|
41 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
42 # dict of template built-in functions |
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
43 funcs = {} |
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
44 templatefunc = registrar.templatefunc(funcs) |
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
45 |
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
46 @templatefunc('date(date[, fmt])') |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
47 def date(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
48 """Format a date. See :hg:`help dates` for formatting |
26106
c568c4db036f
templatefilters: remove redundant 'date' and 'strip' filters
Yuya Nishihara <yuya@tcha.org>
parents:
26105
diff
changeset
|
49 strings. The default is a Unix date format, including the timezone: |
c568c4db036f
templatefilters: remove redundant 'date' and 'strip' filters
Yuya Nishihara <yuya@tcha.org>
parents:
26105
diff
changeset
|
50 "Mon Sep 04 15:13:13 2006 0700".""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
51 if not (1 <= len(args) <= 2): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
52 # i18n: "date" is a keyword |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
53 raise error.ParseError(_("date expects one or two arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
54 |
37225
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
55 date = evaldate(context, mapping, args[0], |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
56 # i18n: "date" is a keyword |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
57 _("date expects a date information")) |
24903
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
58 fmt = None |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
59 if len(args) == 2: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
60 fmt = evalstring(context, mapping, args[1]) |
37225
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
61 if fmt is None: |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
62 return dateutil.datestr(date) |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
63 else: |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
64 return dateutil.datestr(date, fmt) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
65 |
31928
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
66 @templatefunc('dict([[key=]value...])', argspec='*args **kwargs') |
31926
932241b8c644
templater: add dict() constructor
Yuya Nishihara <yuya@tcha.org>
parents:
31922
diff
changeset
|
67 def dict_(context, mapping, args): |
31928
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
68 """Construct a dict from key-value pairs. A key may be omitted if |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
69 a value expression can provide an unambiguous name.""" |
31926
932241b8c644
templater: add dict() constructor
Yuya Nishihara <yuya@tcha.org>
parents:
31922
diff
changeset
|
70 data = util.sortdict() |
31928
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
71 |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
72 for v in args['args']: |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
73 k = templateutil.findsymbolicname(v) |
31928
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
74 if not k: |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
75 raise error.ParseError(_('dict key cannot be inferred')) |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
76 if k in data or k in args['kwargs']: |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
77 raise error.ParseError(_("duplicated dict key '%s' inferred") % k) |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
78 data[k] = evalfuncarg(context, mapping, v) |
277b3e2d711b
templater: add shorthand for building a dict like {"key": key}
Yuya Nishihara <yuya@tcha.org>
parents:
31927
diff
changeset
|
79 |
31926
932241b8c644
templater: add dict() constructor
Yuya Nishihara <yuya@tcha.org>
parents:
31922
diff
changeset
|
80 data.update((k, evalfuncarg(context, mapping, v)) |
932241b8c644
templater: add dict() constructor
Yuya Nishihara <yuya@tcha.org>
parents:
31922
diff
changeset
|
81 for k, v in args['kwargs'].iteritems()) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
82 return templateutil.hybriddict(data) |
31926
932241b8c644
templater: add dict() constructor
Yuya Nishihara <yuya@tcha.org>
parents:
31922
diff
changeset
|
83 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
84 @templatefunc('diff([includepattern [, excludepattern]])') |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
85 def diff(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
86 """Show a diff, optionally |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
87 specifying files to include or exclude.""" |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
88 if len(args) > 2: |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
89 # i18n: "diff" is a keyword |
27293
9e06e7fb037d
grammar: favor zero, one, two over ... or no
timeless <timeless@mozdev.org>
parents:
26587
diff
changeset
|
90 raise error.ParseError(_("diff expects zero, one, or two arguments")) |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
91 |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
92 def getpatterns(i): |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
93 if i < len(args): |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
94 s = evalstring(context, mapping, args[i]).strip() |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
95 if s: |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
96 return [s] |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
97 return [] |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
98 |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
99 ctx = context.resource(mapping, 'ctx') |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
100 chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1))) |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
101 |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
102 return ''.join(chunks) |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
103 |
34458
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
104 @templatefunc('extdata(source)', argspec='source') |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
105 def extdata(context, mapping, args): |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
106 """Show a text read from the specified extdata source. (EXPERIMENTAL)""" |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
107 if 'source' not in args: |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
108 # i18n: "extdata" is a keyword |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
109 raise error.ParseError(_('extdata expects one argument')) |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
110 |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
111 source = evalstring(context, mapping, args['source']) |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
112 cache = context.resource(mapping, 'cache').setdefault('extdata', {}) |
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
113 ctx = context.resource(mapping, 'ctx') |
34458
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
114 if source in cache: |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
115 data = cache[source] |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
116 else: |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
117 data = cache[source] = scmutil.extdatasource(ctx.repo(), source) |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
118 return data.get(ctx.rev(), '') |
a1b89c8ad32d
templater: add experimental support for extdata
Yuya Nishihara <yuya@tcha.org>
parents:
34346
diff
changeset
|
119 |
30008
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
120 @templatefunc('files(pattern)') |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
121 def files(context, mapping, args): |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
122 """All files of the current changeset matching the pattern. See |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
123 :hg:`help patterns`.""" |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
124 if not len(args) == 1: |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
125 # i18n: "files" is a keyword |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
126 raise error.ParseError(_("files expects one argument")) |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
127 |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
128 raw = evalstring(context, mapping, args[0]) |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
129 ctx = context.resource(mapping, 'ctx') |
30008
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
130 m = ctx.match([raw]) |
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
131 files = list(ctx.matches(m)) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
132 return templateutil.compatlist(context, mapping, "file", files) |
30008
e83f89d3b1f7
templates: add built-in files() function
Hannes Oldenburg <hannes.christian.oldenburg@gmail.com>
parents:
29848
diff
changeset
|
133 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
134 @templatefunc('fill(text[, width[, initialident[, hangindent]]])') |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
135 def fill(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
136 """Fill many |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
137 paragraphs with optional indentation. See the "fill" filter.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
138 if not (1 <= len(args) <= 4): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
139 # i18n: "fill" is a keyword |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
140 raise error.ParseError(_("fill expects one to four arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
141 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
142 text = evalstring(context, mapping, args[0]) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
143 width = 76 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
144 initindent = '' |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
145 hangindent = '' |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
146 if 2 <= len(args) <= 4: |
28343
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
147 width = evalinteger(context, mapping, args[1], |
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
148 # i18n: "fill" is a keyword |
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
149 _("fill expects an integer width")) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
150 try: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
151 initindent = evalstring(context, mapping, args[2]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
152 hangindent = evalstring(context, mapping, args[3]) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
153 except IndexError: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
154 pass |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
155 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
156 return templatefilters.fill(text, width, initindent, hangindent) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
157 |
31169
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
158 @templatefunc('formatnode(node)') |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
159 def formatnode(context, mapping, args): |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
160 """Obtain the preferred form of a changeset hash. (DEPRECATED)""" |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
161 if len(args) != 1: |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
162 # i18n: "formatnode" is a keyword |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
163 raise error.ParseError(_("formatnode expects one argument")) |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
164 |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
165 ui = context.resource(mapping, 'ui') |
31169
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
166 node = evalstring(context, mapping, args[0]) |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
167 if ui.debugflag: |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
168 return node |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
169 return templatefilters.short(node) |
48a8b2e5fe31
templater: port formatnode filter from changeset_templater
Yuya Nishihara <yuya@tcha.org>
parents:
31024
diff
changeset
|
170 |
37210
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
171 @templatefunc('mailmap(author)') |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
172 def mailmap(context, mapping, args): |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
173 """Return the author, updated according to the value |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
174 set in the .mailmap file""" |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
175 if len(args) != 1: |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
176 raise error.ParseError(_("mailmap expects one argument")) |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
177 |
37260
8e57c3b0dce4
templatefuncs: do not crash because of invalid value fed to mailmap()
Yuya Nishihara <yuya@tcha.org>
parents:
37244
diff
changeset
|
178 author = evalstring(context, mapping, args[0]) |
37210
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
179 |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
180 cache = context.resource(mapping, 'cache') |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
181 repo = context.resource(mapping, 'repo') |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
182 |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
183 if 'mailmap' not in cache: |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
184 data = repo.wvfs.tryread('.mailmap') |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
185 cache['mailmap'] = stringutil.parsemailmap(data) |
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
186 |
37244
3685a79ea51b
templatefuncs: remove redundant "or author" from mailmap return statement
Connor Sheehan <sheehan@mozilla.com>
parents:
37225
diff
changeset
|
187 return stringutil.mapname(cache['mailmap'], author) |
37210
2a2ce93e12f4
templatefuncs: add mailmap template function
Connor Sheehan <sheehan@mozilla.com>
parents:
37163
diff
changeset
|
188 |
31887
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
189 @templatefunc('pad(text, width[, fillchar=\' \'[, left=False]])', |
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
190 argspec='text width fillchar left') |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
191 def pad(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
192 """Pad text with a |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
193 fill character.""" |
31887
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
194 if 'text' not in args or 'width' not in args: |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
195 # i18n: "pad" is a keyword |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
196 raise error.ParseError(_("pad() expects two to four arguments")) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
197 |
31887
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
198 width = evalinteger(context, mapping, args['width'], |
28345
d81437c91a26
templater: fix pad() to evaluate int argument and handle error
Yuya Nishihara <yuya@tcha.org>
parents:
28344
diff
changeset
|
199 # i18n: "pad" is a keyword |
d81437c91a26
templater: fix pad() to evaluate int argument and handle error
Yuya Nishihara <yuya@tcha.org>
parents:
28344
diff
changeset
|
200 _("pad() expects an integer width")) |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
201 |
31887
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
202 text = evalstring(context, mapping, args['text']) |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
203 |
29818
407879b0893b
templater: rename "right" argument of pad() function
Yuya Nishihara <yuya@tcha.org>
parents:
29817
diff
changeset
|
204 left = False |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
205 fillchar = ' ' |
31887
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
206 if 'fillchar' in args: |
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
207 fillchar = evalstring(context, mapping, args['fillchar']) |
31521
44c591f63458
templater: make pad() strip color codes before computing width (issue5416)
Yuya Nishihara <yuya@tcha.org>
parents:
31520
diff
changeset
|
208 if len(color.stripeffects(fillchar)) != 1: |
31519
3725986b151a
templater: reject bad fillchar argument passed to pad()
Yuya Nishihara <yuya@tcha.org>
parents:
31169
diff
changeset
|
209 # i18n: "pad" is a keyword |
3725986b151a
templater: reject bad fillchar argument passed to pad()
Yuya Nishihara <yuya@tcha.org>
parents:
31169
diff
changeset
|
210 raise error.ParseError(_("pad() expects a single fill character")) |
31887
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
211 if 'left' in args: |
f7b3677f66cd
templater: port pad() to take keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31886
diff
changeset
|
212 left = evalboolean(context, mapping, args['left']) |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
213 |
31521
44c591f63458
templater: make pad() strip color codes before computing width (issue5416)
Yuya Nishihara <yuya@tcha.org>
parents:
31520
diff
changeset
|
214 fillwidth = width - encoding.colwidth(color.stripeffects(text)) |
31520
6f150bb19317
templater: make pad() compute actual width
Yuya Nishihara <yuya@tcha.org>
parents:
31519
diff
changeset
|
215 if fillwidth <= 0: |
6f150bb19317
templater: make pad() compute actual width
Yuya Nishihara <yuya@tcha.org>
parents:
31519
diff
changeset
|
216 return text |
29818
407879b0893b
templater: rename "right" argument of pad() function
Yuya Nishihara <yuya@tcha.org>
parents:
29817
diff
changeset
|
217 if left: |
31520
6f150bb19317
templater: make pad() compute actual width
Yuya Nishihara <yuya@tcha.org>
parents:
31519
diff
changeset
|
218 return fillchar * fillwidth + text |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
219 else: |
31520
6f150bb19317
templater: make pad() compute actual width
Yuya Nishihara <yuya@tcha.org>
parents:
31519
diff
changeset
|
220 return text + fillchar * fillwidth |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
221 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
222 @templatefunc('indent(text, indentchars[, firstline])') |
25489
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
223 def indent(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
224 """Indents all non-empty lines |
25489
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
225 with the characters given in the indentchars string. An optional |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
226 third parameter will override the indent for the first line only |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
227 if present.""" |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
228 if not (2 <= len(args) <= 3): |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
229 # i18n: "indent" is a keyword |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
230 raise error.ParseError(_("indent() expects two or three arguments")) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
231 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
232 text = evalstring(context, mapping, args[0]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
233 indent = evalstring(context, mapping, args[1]) |
25489
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
234 |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
235 if len(args) == 3: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
236 firstline = evalstring(context, mapping, args[2]) |
25489
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
237 else: |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
238 firstline = indent |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
239 |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
240 # the indent function doesn't indent the first line, so we do it here |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
241 return templatefilters.indent(firstline + text, indent) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
242 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
243 @templatefunc('get(dict, key)') |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
244 def get(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
245 """Get an attribute/key from an object. Some keywords |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
246 are complex types. This function allows you to obtain the value of an |
26197 | 247 attribute on these types.""" |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
248 if len(args) != 2: |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
249 # i18n: "get" is a keyword |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
250 raise error.ParseError(_("get() expects two arguments")) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
251 |
28331
2874db5462d3
templater: fix get() to evaluate arguments eagerly
Yuya Nishihara <yuya@tcha.org>
parents:
28225
diff
changeset
|
252 dictarg = evalfuncarg(context, mapping, args[0]) |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
253 if not util.safehasattr(dictarg, 'get'): |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
254 # i18n: "get" is a keyword |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
255 raise error.ParseError(_("get() expects a dict as first argument")) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
256 |
28331
2874db5462d3
templater: fix get() to evaluate arguments eagerly
Yuya Nishihara <yuya@tcha.org>
parents:
28225
diff
changeset
|
257 key = evalfuncarg(context, mapping, args[1]) |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
258 return templateutil.getdictitem(dictarg, key) |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
259 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
260 @templatefunc('if(expr, then[, else])') |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
261 def if_(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
262 """Conditionally execute based on the result of |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
263 an expression.""" |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
264 if not (2 <= len(args) <= 3): |
17890
ca6850b9dd9e
i18n: add "i18n" comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17729
diff
changeset
|
265 # i18n: "if" is a keyword |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
266 raise error.ParseError(_("if expects two or three arguments")) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
267 |
29816
034412ca28c3
templater: fix if() to not evaluate False as bool('False')
Yuya Nishihara <yuya@tcha.org>
parents:
29815
diff
changeset
|
268 test = evalboolean(context, mapping, args[0]) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
269 if test: |
37015
a318bb154d42
templatefuncs: do not stringify result of if*() expression
Yuya Nishihara <yuya@tcha.org>
parents:
36922
diff
changeset
|
270 return evalrawexp(context, mapping, args[1]) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
271 elif len(args) == 3: |
37015
a318bb154d42
templatefuncs: do not stringify result of if*() expression
Yuya Nishihara <yuya@tcha.org>
parents:
36922
diff
changeset
|
272 return evalrawexp(context, mapping, args[2]) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
273 |
30049
f18cc848b48e
templater: use "needle" and "haystack" as (meta-)variables for ifcontains()
Anton Shestakov <av6@dwimlabs.net>
parents:
30008
diff
changeset
|
274 @templatefunc('ifcontains(needle, haystack, then[, else])') |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
275 def ifcontains(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
276 """Conditionally execute based |
30049
f18cc848b48e
templater: use "needle" and "haystack" as (meta-)variables for ifcontains()
Anton Shestakov <av6@dwimlabs.net>
parents:
30008
diff
changeset
|
277 on whether the item "needle" is in "haystack".""" |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
278 if not (3 <= len(args) <= 4): |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
279 # i18n: "ifcontains" is a keyword |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
280 raise error.ParseError(_("ifcontains expects three or four arguments")) |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
281 |
30049
f18cc848b48e
templater: use "needle" and "haystack" as (meta-)variables for ifcontains()
Anton Shestakov <av6@dwimlabs.net>
parents:
30008
diff
changeset
|
282 haystack = evalfuncarg(context, mapping, args[1]) |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37015
diff
changeset
|
283 keytype = getattr(haystack, 'keytype', None) |
34659
3edfd472f3cb
templater: fix ifcontains() to handle type mismatch gracefully
Yuya Nishihara <yuya@tcha.org>
parents:
34581
diff
changeset
|
284 try: |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37015
diff
changeset
|
285 needle = evalrawexp(context, mapping, args[0]) |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37260
diff
changeset
|
286 needle = templateutil.unwrapastype(context, mapping, needle, |
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37260
diff
changeset
|
287 keytype or bytes) |
34659
3edfd472f3cb
templater: fix ifcontains() to handle type mismatch gracefully
Yuya Nishihara <yuya@tcha.org>
parents:
34581
diff
changeset
|
288 found = (needle in haystack) |
3edfd472f3cb
templater: fix ifcontains() to handle type mismatch gracefully
Yuya Nishihara <yuya@tcha.org>
parents:
34581
diff
changeset
|
289 except error.ParseError: |
3edfd472f3cb
templater: fix ifcontains() to handle type mismatch gracefully
Yuya Nishihara <yuya@tcha.org>
parents:
34581
diff
changeset
|
290 found = False |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
291 |
34659
3edfd472f3cb
templater: fix ifcontains() to handle type mismatch gracefully
Yuya Nishihara <yuya@tcha.org>
parents:
34581
diff
changeset
|
292 if found: |
37015
a318bb154d42
templatefuncs: do not stringify result of if*() expression
Yuya Nishihara <yuya@tcha.org>
parents:
36922
diff
changeset
|
293 return evalrawexp(context, mapping, args[2]) |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
294 elif len(args) == 4: |
37015
a318bb154d42
templatefuncs: do not stringify result of if*() expression
Yuya Nishihara <yuya@tcha.org>
parents:
36922
diff
changeset
|
295 return evalrawexp(context, mapping, args[3]) |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
296 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
297 @templatefunc('ifeq(expr1, expr2, then[, else])') |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
298 def ifeq(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
299 """Conditionally execute based on |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
300 whether 2 items are equivalent.""" |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
301 if not (3 <= len(args) <= 4): |
17890
ca6850b9dd9e
i18n: add "i18n" comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17729
diff
changeset
|
302 # i18n: "ifeq" is a keyword |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
303 raise error.ParseError(_("ifeq expects three or four arguments")) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
304 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
305 test = evalstring(context, mapping, args[0]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
306 match = evalstring(context, mapping, args[1]) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
307 if test == match: |
37015
a318bb154d42
templatefuncs: do not stringify result of if*() expression
Yuya Nishihara <yuya@tcha.org>
parents:
36922
diff
changeset
|
308 return evalrawexp(context, mapping, args[2]) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
309 elif len(args) == 4: |
37015
a318bb154d42
templatefuncs: do not stringify result of if*() expression
Yuya Nishihara <yuya@tcha.org>
parents:
36922
diff
changeset
|
310 return evalrawexp(context, mapping, args[3]) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
311 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
312 @templatefunc('join(list, sep)') |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
313 def join(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
314 """Join items in a list with a delimiter.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
315 if not (1 <= len(args) <= 2): |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
316 # i18n: "join" is a keyword |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
317 raise error.ParseError(_("join expects one or two arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
318 |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
319 joinset = evalrawexp(context, mapping, args[0]) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
320 joiner = " " |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
321 if len(args) > 1: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
322 joiner = evalstring(context, mapping, args[1]) |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
323 if isinstance(joinset, templateutil.wrapped): |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
324 return joinset.join(context, mapping, joiner) |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
325 # TODO: perhaps a generator should be stringify()-ed here, but we can't |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
326 # because hgweb abuses it as a keyword that returns a list of dicts. |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
327 joinset = templateutil.unwrapvalue(context, mapping, joinset) |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
328 return templateutil.joinitems(pycompat.maybebytestr(joinset), joiner) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
329 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
330 @templatefunc('label(label, expr)') |
18289
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
331 def label(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
332 """Apply a label to generated content. Content with |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
333 a label applied can result in additional post-processing, such as |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
334 automatic colorization.""" |
18289
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
335 if len(args) != 2: |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
336 # i18n: "label" is a keyword |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
337 raise error.ParseError(_("label expects two arguments")) |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
338 |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
339 ui = context.resource(mapping, 'ui') |
28374
af3bd9d1dbc1
templater: move label() function from color extension
Yuya Nishihara <yuya@tcha.org>
parents:
28373
diff
changeset
|
340 thing = evalstring(context, mapping, args[1]) |
af3bd9d1dbc1
templater: move label() function from color extension
Yuya Nishihara <yuya@tcha.org>
parents:
28373
diff
changeset
|
341 # preserve unknown symbol as literal so effects like 'red', 'bold', |
af3bd9d1dbc1
templater: move label() function from color extension
Yuya Nishihara <yuya@tcha.org>
parents:
28373
diff
changeset
|
342 # etc. don't need to be quoted |
af3bd9d1dbc1
templater: move label() function from color extension
Yuya Nishihara <yuya@tcha.org>
parents:
28373
diff
changeset
|
343 label = evalstringliteral(context, mapping, args[0]) |
af3bd9d1dbc1
templater: move label() function from color extension
Yuya Nishihara <yuya@tcha.org>
parents:
28373
diff
changeset
|
344 |
28384
3356bf61fa25
formatter: make labels work with templated output
Kostia Balytskyi <ikostia@fb.com>
parents:
28374
diff
changeset
|
345 return ui.label(thing, label) |
18289
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
346 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
347 @templatefunc('latesttag([pattern])') |
26485
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
348 def latesttag(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
349 """The global tags matching the given pattern on the |
31850
f0d719e513fc
templatekw: clarify the result of {latesttag} when no tag exists
Matt Harbison <matt_harbison@yahoo.com>
parents:
31807
diff
changeset
|
350 most recent globally tagged ancestor of this changeset. |
f0d719e513fc
templatekw: clarify the result of {latesttag} when no tag exists
Matt Harbison <matt_harbison@yahoo.com>
parents:
31807
diff
changeset
|
351 If no such tags exist, the "{tag}" template resolves to |
f0d719e513fc
templatekw: clarify the result of {latesttag} when no tag exists
Matt Harbison <matt_harbison@yahoo.com>
parents:
31807
diff
changeset
|
352 the string "null".""" |
26485
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
353 if len(args) > 1: |
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
354 # i18n: "latesttag" is a keyword |
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
355 raise error.ParseError(_("latesttag expects at most one argument")) |
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
356 |
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
357 pattern = None |
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
358 if len(args) == 1: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
359 pattern = evalstring(context, mapping, args[0]) |
36596
b5d39a09656a
templatekw: switch latesttags template keywords to new API
Yuya Nishihara <yuya@tcha.org>
parents:
36595
diff
changeset
|
360 return templatekw.showlatesttags(context, mapping, pattern) |
26485
43bf9471fae9
templater: introduce {latesttag()} function to match a pattern (issue4184)
Matt Harbison <matt_harbison@yahoo.com>
parents:
26334
diff
changeset
|
361 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
362 @templatefunc('localdate(date[, tz])') |
26127
7012be5ab5bd
templater: port localdate filter to a function
Yuya Nishihara <yuya@tcha.org>
parents:
26125
diff
changeset
|
363 def localdate(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
364 """Converts a date to the specified timezone. |
26128
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
365 The default is local date.""" |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
366 if not (1 <= len(args) <= 2): |
26127
7012be5ab5bd
templater: port localdate filter to a function
Yuya Nishihara <yuya@tcha.org>
parents:
26125
diff
changeset
|
367 # i18n: "localdate" is a keyword |
26128
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
368 raise error.ParseError(_("localdate expects one or two arguments")) |
26127
7012be5ab5bd
templater: port localdate filter to a function
Yuya Nishihara <yuya@tcha.org>
parents:
26125
diff
changeset
|
369 |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37210
diff
changeset
|
370 date = evaldate(context, mapping, args[0], |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37210
diff
changeset
|
371 # i18n: "localdate" is a keyword |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37210
diff
changeset
|
372 _("localdate expects a date information")) |
26128
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
373 if len(args) >= 2: |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
374 tzoffset = None |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
375 tz = evalfuncarg(context, mapping, args[1]) |
36550
7f6be7121b28
py3: replace type 'str' by 'bytes' in templater.py
Yuya Nishihara <yuya@tcha.org>
parents:
36546
diff
changeset
|
376 if isinstance(tz, bytes): |
36607
c6061cadb400
util: extract all date-related utils in utils/dateutil module
Boris Feld <boris.feld@octobus.net>
parents:
36596
diff
changeset
|
377 tzoffset, remainder = dateutil.parsetimezone(tz) |
29636
84ef4517de03
date: refactor timezone parsing
Matt Mackall <mpm@selenic.com>
parents:
29085
diff
changeset
|
378 if remainder: |
84ef4517de03
date: refactor timezone parsing
Matt Mackall <mpm@selenic.com>
parents:
29085
diff
changeset
|
379 tzoffset = None |
26128
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
380 if tzoffset is None: |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
381 try: |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
382 tzoffset = int(tz) |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
383 except (TypeError, ValueError): |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
384 # i18n: "localdate" is a keyword |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
385 raise error.ParseError(_("localdate expects a timezone")) |
51f6940d3b4f
templater: add optional timezone argument to localdate()
Yuya Nishihara <yuya@tcha.org>
parents:
26127
diff
changeset
|
386 else: |
36607
c6061cadb400
util: extract all date-related utils in utils/dateutil module
Boris Feld <boris.feld@octobus.net>
parents:
36596
diff
changeset
|
387 tzoffset = dateutil.makedate()[1] |
26127
7012be5ab5bd
templater: port localdate filter to a function
Yuya Nishihara <yuya@tcha.org>
parents:
26125
diff
changeset
|
388 return (date[0], tzoffset) |
7012be5ab5bd
templater: port localdate filter to a function
Yuya Nishihara <yuya@tcha.org>
parents:
26125
diff
changeset
|
389 |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
390 @templatefunc('max(iterable)') |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
391 def max_(context, mapping, args, **kwargs): |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
392 """Return the max of an iterable""" |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
393 if len(args) != 1: |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
394 # i18n: "max" is a keyword |
35386
fdd09d87635b
templater: fix "one arguments"
Anton Shestakov <av6@dwimlabs.net>
parents:
34838
diff
changeset
|
395 raise error.ParseError(_("max expects one argument")) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
396 |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
397 iterable = evalfuncarg(context, mapping, args[0]) |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
398 try: |
36544
a16fceb686a7
py3: fix join(), min(), and max() template functions over string
Yuya Nishihara <yuya@tcha.org>
parents:
36509
diff
changeset
|
399 x = max(pycompat.maybebytestr(iterable)) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
400 except (TypeError, ValueError): |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
401 # i18n: "max" is a keyword |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
402 raise error.ParseError(_("max first argument should be an iterable")) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
403 return templateutil.wraphybridvalue(iterable, x, x) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
404 |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
405 @templatefunc('min(iterable)') |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
406 def min_(context, mapping, args, **kwargs): |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
407 """Return the min of an iterable""" |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
408 if len(args) != 1: |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
409 # i18n: "min" is a keyword |
35386
fdd09d87635b
templater: fix "one arguments"
Anton Shestakov <av6@dwimlabs.net>
parents:
34838
diff
changeset
|
410 raise error.ParseError(_("min expects one argument")) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
411 |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
412 iterable = evalfuncarg(context, mapping, args[0]) |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
413 try: |
36544
a16fceb686a7
py3: fix join(), min(), and max() template functions over string
Yuya Nishihara <yuya@tcha.org>
parents:
36509
diff
changeset
|
414 x = min(pycompat.maybebytestr(iterable)) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
415 except (TypeError, ValueError): |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
416 # i18n: "min" is a keyword |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
417 raise error.ParseError(_("min first argument should be an iterable")) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
418 return templateutil.wraphybridvalue(iterable, x, x) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
419 |
30115
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
420 @templatefunc('mod(a, b)') |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
421 def mod(context, mapping, args): |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
422 """Calculate a mod b such that a / b + a mod b == a""" |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
423 if not len(args) == 2: |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
424 # i18n: "mod" is a keyword |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
425 raise error.ParseError(_("mod expects two arguments")) |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
426 |
30116
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
427 func = lambda a, b: a % b |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
428 return templateutil.runarithmetic(context, mapping, |
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
429 (func, args[0], args[1])) |
30115
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
430 |
34287
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
431 @templatefunc('obsfateoperations(markers)') |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
432 def obsfateoperations(context, mapping, args): |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
433 """Compute obsfate related information based on markers (EXPERIMENTAL)""" |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
434 if len(args) != 1: |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
435 # i18n: "obsfateoperations" is a keyword |
35386
fdd09d87635b
templater: fix "one arguments"
Anton Shestakov <av6@dwimlabs.net>
parents:
34838
diff
changeset
|
436 raise error.ParseError(_("obsfateoperations expects one argument")) |
34287
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
437 |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
438 markers = evalfuncarg(context, mapping, args[0]) |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
439 |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
440 try: |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
441 data = obsutil.markersoperations(markers) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
442 return templateutil.hybridlist(data, name='operation') |
34287
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
443 except (TypeError, KeyError): |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
444 # i18n: "obsfateoperations" is a keyword |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
445 errmsg = _("obsfateoperations first argument should be an iterable") |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
446 raise error.ParseError(errmsg) |
7cdc8c5a481a
templates: introduce a obsfateoperation() function
Martin von Zweigbergk <martinvonz@google.com>
parents:
34250
diff
changeset
|
447 |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
448 @templatefunc('obsfatedate(markers)') |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
449 def obsfatedate(context, mapping, args): |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
450 """Compute obsfate related information based on markers (EXPERIMENTAL)""" |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
451 if len(args) != 1: |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
452 # i18n: "obsfatedate" is a keyword |
35386
fdd09d87635b
templater: fix "one arguments"
Anton Shestakov <av6@dwimlabs.net>
parents:
34838
diff
changeset
|
453 raise error.ParseError(_("obsfatedate expects one argument")) |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
454 |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
455 markers = evalfuncarg(context, mapping, args[0]) |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
456 |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
457 try: |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
458 data = obsutil.markersdates(markers) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
459 return templateutil.hybridlist(data, name='date', fmt='%d %d') |
33995
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
460 except (TypeError, KeyError): |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
461 # i18n: "obsfatedate" is a keyword |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
462 errmsg = _("obsfatedate first argument should be an iterable") |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
463 raise error.ParseError(errmsg) |
c35c0f54f420
template: compute dates in obsfatedate
Boris Feld <boris.feld@octobus.net>
parents:
33994
diff
changeset
|
464 |
33994
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
465 @templatefunc('obsfateusers(markers)') |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
466 def obsfateusers(context, mapping, args): |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
467 """Compute obsfate related information based on markers (EXPERIMENTAL)""" |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
468 if len(args) != 1: |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
469 # i18n: "obsfateusers" is a keyword |
35386
fdd09d87635b
templater: fix "one arguments"
Anton Shestakov <av6@dwimlabs.net>
parents:
34838
diff
changeset
|
470 raise error.ParseError(_("obsfateusers expects one argument")) |
33994
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
471 |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
472 markers = evalfuncarg(context, mapping, args[0]) |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
473 |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
474 try: |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
475 data = obsutil.markersusers(markers) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
476 return templateutil.hybridlist(data, name='user') |
33994
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
477 except (TypeError, KeyError, ValueError): |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
478 # i18n: "obsfateusers" is a keyword |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
479 msg = _("obsfateusers first argument should be an iterable of " |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
480 "obsmakers") |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
481 raise error.ParseError(msg) |
38f08eaba6b0
template: compute user in obsfateusers
Boris Feld <boris.feld@octobus.net>
parents:
33993
diff
changeset
|
482 |
35010
b81ad5b78a81
obsfate: makes successorsetverb takes the markers as argument
Boris Feld <boris.feld@octobus.net>
parents:
34838
diff
changeset
|
483 @templatefunc('obsfateverb(successors, markers)') |
33993
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
484 def obsfateverb(context, mapping, args): |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
485 """Compute obsfate related information based on successors (EXPERIMENTAL)""" |
35010
b81ad5b78a81
obsfate: makes successorsetverb takes the markers as argument
Boris Feld <boris.feld@octobus.net>
parents:
34838
diff
changeset
|
486 if len(args) != 2: |
33993
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
487 # i18n: "obsfateverb" is a keyword |
35010
b81ad5b78a81
obsfate: makes successorsetverb takes the markers as argument
Boris Feld <boris.feld@octobus.net>
parents:
34838
diff
changeset
|
488 raise error.ParseError(_("obsfateverb expects two arguments")) |
33993
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
489 |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
490 successors = evalfuncarg(context, mapping, args[0]) |
35010
b81ad5b78a81
obsfate: makes successorsetverb takes the markers as argument
Boris Feld <boris.feld@octobus.net>
parents:
34838
diff
changeset
|
491 markers = evalfuncarg(context, mapping, args[1]) |
33993
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
492 |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
493 try: |
35010
b81ad5b78a81
obsfate: makes successorsetverb takes the markers as argument
Boris Feld <boris.feld@octobus.net>
parents:
34838
diff
changeset
|
494 return obsutil.obsfateverb(successors, markers) |
33993
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
495 except TypeError: |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
496 # i18n: "obsfateverb" is a keyword |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
497 errmsg = _("obsfateverb first argument should be countable") |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
498 raise error.ParseError(errmsg) |
3d0f8918351b
template: compute verb in obsfateverb
Boris Feld <boris.feld@octobus.net>
parents:
33554
diff
changeset
|
499 |
30083
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
500 @templatefunc('relpath(path)') |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
501 def relpath(context, mapping, args): |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
502 """Convert a repository-absolute path into a filesystem path relative to |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
503 the current working directory.""" |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
504 if len(args) != 1: |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
505 # i18n: "relpath" is a keyword |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
506 raise error.ParseError(_("relpath expects one argument")) |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
507 |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
508 repo = context.resource(mapping, 'ctx').repo() |
30083
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
509 path = evalstring(context, mapping, args[0]) |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
510 return repo.pathto(path) |
bd1f043d1ea3
templater: add relpath() to convert repo path to relative path (issue5394)
Yuya Nishihara <yuya@tcha.org>
parents:
30049
diff
changeset
|
511 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
512 @templatefunc('revset(query[, formatargs...])') |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
513 def revset(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
514 """Execute a revision set query. See |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
515 :hg:`help revset`.""" |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
516 if not len(args) > 0: |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
517 # i18n: "revset" is a keyword |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
518 raise error.ParseError(_("revset expects one or more arguments")) |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
519 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
520 raw = evalstring(context, mapping, args[0]) |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
521 ctx = context.resource(mapping, 'ctx') |
24337
696ab1a24ae0
templater: replace 'ctx._repo' with 'ctx.repo()'
Matt Harbison <matt_harbison@yahoo.com>
parents:
24306
diff
changeset
|
522 repo = ctx.repo() |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
523 |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
524 def query(expr): |
37674
f83cb91b052e
revset: pass in lookup function instead of repo (API)
Yuya Nishihara <yuya@tcha.org>
parents:
37327
diff
changeset
|
525 m = revsetmod.match(repo.ui, expr, lookup=revsetmod.lookupfn(repo)) |
24114
fafd9a1284cf
revset: make match function initiate query from full set by default
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
526 return m(repo) |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
527 |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
528 if len(args) > 1: |
28333
41373244f4e5
templater: fix revset() to evaluate format arguments eagerly
Yuya Nishihara <yuya@tcha.org>
parents:
28332
diff
changeset
|
529 formatargs = [evalfuncarg(context, mapping, a) for a in args[1:]] |
31024
0b8356705de6
revset: split language services to revsetlang module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30625
diff
changeset
|
530 revs = query(revsetlang.formatspec(raw, *formatargs)) |
28178
96f2d50fb9f6
templater: factor out type conversion of revset() result
Yuya Nishihara <yuya@tcha.org>
parents:
27940
diff
changeset
|
531 revs = list(revs) |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
532 else: |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
533 cache = context.resource(mapping, 'cache') |
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
534 revsetcache = cache.setdefault("revsetcache", {}) |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
535 if raw in revsetcache: |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
536 revs = revsetcache[raw] |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
537 else: |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
538 revs = query(raw) |
28178
96f2d50fb9f6
templater: factor out type conversion of revset() result
Yuya Nishihara <yuya@tcha.org>
parents:
27940
diff
changeset
|
539 revs = list(revs) |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
540 revsetcache[raw] = revs |
36595
2da414105809
templatekw: switch revset() to new API
Yuya Nishihara <yuya@tcha.org>
parents:
36591
diff
changeset
|
541 return templatekw.showrevslist(context, mapping, "revision", revs) |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
542 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
543 @templatefunc('rstdoc(text, style)') |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
544 def rstdoc(context, mapping, args): |
30332
318a24b52eeb
spelling: fixes of non-dictionary words
Mads Kiilerich <madski@unity3d.com>
parents:
30232
diff
changeset
|
545 """Format reStructuredText.""" |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
546 if len(args) != 2: |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
547 # i18n: "rstdoc" is a keyword |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
548 raise error.ParseError(_("rstdoc expects two arguments")) |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
549 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
550 text = evalstring(context, mapping, args[0]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
551 style = evalstring(context, mapping, args[1]) |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
552 |
19079
1e433b5457fd
hgweb: make help verbose again (issue3899)
Alexander Plavin <me@aplavin.ru>
parents:
19058
diff
changeset
|
553 return minirst.format(text, style=style, keep=['verbose']) |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
554 |
31886
bdda942f4b9c
templater: add support for keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31885
diff
changeset
|
555 @templatefunc('separate(sep, args)', argspec='sep *args') |
29085
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
556 def separate(context, mapping, args): |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
557 """Add a separator between non-empty arguments.""" |
31886
bdda942f4b9c
templater: add support for keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31885
diff
changeset
|
558 if 'sep' not in args: |
29085
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
559 # i18n: "separate" is a keyword |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
560 raise error.ParseError(_("separate expects at least one argument")) |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
561 |
31886
bdda942f4b9c
templater: add support for keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31885
diff
changeset
|
562 sep = evalstring(context, mapping, args['sep']) |
29085
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
563 first = True |
31886
bdda942f4b9c
templater: add support for keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
31885
diff
changeset
|
564 for arg in args['args']: |
29085
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
565 argstr = evalstring(context, mapping, arg) |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
566 if not argstr: |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
567 continue |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
568 if first: |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
569 first = False |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
570 else: |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
571 yield sep |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
572 yield argstr |
df838803c1d4
templater: add separate() template function
Martin von Zweigbergk <martinvonz@google.com>
parents:
28957
diff
changeset
|
573 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
574 @templatefunc('shortest(node, minlength=4)') |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
575 def shortest(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
576 """Obtain the shortest representation of |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
577 a node.""" |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
578 if not (1 <= len(args) <= 2): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
579 # i18n: "shortest" is a keyword |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
580 raise error.ParseError(_("shortest() expects one or two arguments")) |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
581 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
582 node = evalstring(context, mapping, args[0]) |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
583 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
584 minlength = 4 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
585 if len(args) > 1: |
28346
542d200bd261
templater: fix shortest() to evaluate int argument and handle error
Yuya Nishihara <yuya@tcha.org>
parents:
28345
diff
changeset
|
586 minlength = evalinteger(context, mapping, args[1], |
542d200bd261
templater: fix shortest() to evaluate int argument and handle error
Yuya Nishihara <yuya@tcha.org>
parents:
28345
diff
changeset
|
587 # i18n: "shortest" is a keyword |
542d200bd261
templater: fix shortest() to evaluate int argument and handle error
Yuya Nishihara <yuya@tcha.org>
parents:
28345
diff
changeset
|
588 _("shortest() expects an integer minlength")) |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
589 |
30232
362740e05460
templater: use unfiltered changelog to calculate shortest() at constant time
Yuya Nishihara <yuya@tcha.org>
parents:
30231
diff
changeset
|
590 # _partialmatch() of filtered changelog could take O(len(repo)) time, |
362740e05460
templater: use unfiltered changelog to calculate shortest() at constant time
Yuya Nishihara <yuya@tcha.org>
parents:
30231
diff
changeset
|
591 # which would be unacceptably slow. so we look for hash collision in |
362740e05460
templater: use unfiltered changelog to calculate shortest() at constant time
Yuya Nishihara <yuya@tcha.org>
parents:
30231
diff
changeset
|
592 # unfiltered space, which means some hashes may be slightly longer. |
37680
e743b8524d60
scmutil: introduce shortesthexnodeidprefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37674
diff
changeset
|
593 repo = context.resource(mapping, 'ctx')._repo |
e743b8524d60
scmutil: introduce shortesthexnodeidprefix()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37674
diff
changeset
|
594 return scmutil.shortesthexnodeidprefix(repo.unfiltered(), node, minlength) |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
595 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
596 @templatefunc('strip(text[, chars])') |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
597 def strip(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
598 """Strip characters from a string. By default, |
26106
c568c4db036f
templatefilters: remove redundant 'date' and 'strip' filters
Yuya Nishihara <yuya@tcha.org>
parents:
26105
diff
changeset
|
599 strips all leading and trailing whitespace.""" |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
600 if not (1 <= len(args) <= 2): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
601 # i18n: "strip" is a keyword |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
602 raise error.ParseError(_("strip expects one or two arguments")) |
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
603 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
604 text = evalstring(context, mapping, args[0]) |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
605 if len(args) == 2: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
606 chars = evalstring(context, mapping, args[1]) |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
607 return text.strip(chars) |
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
608 return text.strip() |
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
609 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
610 @templatefunc('sub(pattern, replacement, expression)') |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
611 def sub(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
612 """Perform text substitution |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
613 using regular expressions.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
614 if len(args) != 3: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
615 # i18n: "sub" is a keyword |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
616 raise error.ParseError(_("sub expects three arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
617 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
618 pat = evalstring(context, mapping, args[0]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
619 rpl = evalstring(context, mapping, args[1]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
620 src = evalstring(context, mapping, args[2]) |
26188
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
621 try: |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
622 patre = re.compile(pat) |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
623 except re.error: |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
624 # i18n: "sub" is a keyword |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
625 raise error.ParseError(_("sub got an invalid pattern: %s") % pat) |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
626 try: |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
627 yield patre.sub(rpl, src) |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
628 except re.error: |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
629 # i18n: "sub" is a keyword |
662ea52d5dca
templater: catch regexp error at sub() function
Yuya Nishihara <yuya@tcha.org>
parents:
26128
diff
changeset
|
630 raise error.ParseError(_("sub got an invalid replacement: %s") % rpl) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
631 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
632 @templatefunc('startswith(pattern, text)') |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
633 def startswith(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
634 """Returns the value from the "text" argument |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
635 if it begins with the content from the "pattern" argument.""" |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
636 if len(args) != 2: |
21960
2896d450fec4
templater: add i18n comments to error messages of newly added functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21846
diff
changeset
|
637 # i18n: "startswith" is a keyword |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
638 raise error.ParseError(_("startswith expects two arguments")) |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
639 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
640 patn = evalstring(context, mapping, args[0]) |
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
641 text = evalstring(context, mapping, args[1]) |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
642 if text.startswith(patn): |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
643 return text |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
644 return '' |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
645 |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
646 @templatefunc('word(number, text[, separator])') |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
647 def word(context, mapping, args): |
28696
efa192203623
templater: use templatefunc to mark a function as template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28695
diff
changeset
|
648 """Return the nth word from a string.""" |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
649 if not (2 <= len(args) <= 3): |
21960
2896d450fec4
templater: add i18n comments to error messages of newly added functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21846
diff
changeset
|
650 # i18n: "word" is a keyword |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
651 raise error.ParseError(_("word expects two or three arguments, got %d") |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
652 % len(args)) |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
653 |
28343
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
654 num = evalinteger(context, mapping, args[0], |
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
655 # i18n: "word" is a keyword |
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
656 _("word expects an integer index")) |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
657 text = evalstring(context, mapping, args[1]) |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
658 if len(args) == 3: |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
659 splitter = evalstring(context, mapping, args[2]) |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
660 else: |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
661 splitter = None |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
662 |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
663 tokens = text.split(splitter) |
26502
4ca98a389152
templater: protect word() from crashing on out of range negative value
Matt Harbison <matt_harbison@yahoo.com>
parents:
25815
diff
changeset
|
664 if num >= len(tokens) or num < -len(tokens): |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
665 return '' |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
666 else: |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
667 return tokens[num] |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
668 |
28695
cc103bd0dbf9
registrar: add templatefunc to mark a function as template function (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28687
diff
changeset
|
669 def loadfunction(ui, extname, registrarobj): |
cc103bd0dbf9
registrar: add templatefunc to mark a function as template function (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28687
diff
changeset
|
670 """Load template function from specified registrarobj |
cc103bd0dbf9
registrar: add templatefunc to mark a function as template function (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28687
diff
changeset
|
671 """ |
cc103bd0dbf9
registrar: add templatefunc to mark a function as template function (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28687
diff
changeset
|
672 for name, func in registrarobj._table.iteritems(): |
cc103bd0dbf9
registrar: add templatefunc to mark a function as template function (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28687
diff
changeset
|
673 funcs[name] = func |
cc103bd0dbf9
registrar: add templatefunc to mark a function as template function (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28687
diff
changeset
|
674 |
24601
d80819f67d59
templater: tell hggettext to collect help of template functions
Yuya Nishihara <yuya@tcha.org>
parents:
24586
diff
changeset
|
675 # tell hggettext to extract docstrings from these functions: |
d80819f67d59
templater: tell hggettext to collect help of template functions
Yuya Nishihara <yuya@tcha.org>
parents:
24586
diff
changeset
|
676 i18nfunctions = funcs.values() |