mercurial-scm/hg-stable: mercurial/templater.py annotate

annotate mercurial/templater.py @ 34335:dd28b1f55eb8

templatekw: just pass underlying value (or key) to joinfmt() function Before, iter(hybrid) was proxied to hybrid.gen, which generated formatted strings. That's why we had to apply joinfmt() to the dicts generated by hybrid.itermaps(). Since this weird API was fixed at a0f2d83f8083, we can get rid of the makemap() calls from join().

author	Yuya Nishihara <yuya@tcha.org>
date	Sun, 24 Sep 2017 15:22:46 +0900
parents	e60c601953d7
children	6367318327f0

rev	line source
1909 37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1 # templater.py - template expansion for output
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 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9842 diff changeset	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
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	8 from __future__ import absolute_import, print_function
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 os
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	11 import re
17982 e06e9fd2d99f template engine: convert generator-based iterator to list-based iterator Weiwen <weiwen@fb.com> parents: 17890 diff changeset	12 import types
25985 7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	13
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	14 from .i18n import _
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	15 from . import (
31527 44c591f63458 templater: make pad() strip color codes before computing width (issue5416) Yuya Nishihara <yuya@tcha.org> parents: 31526 diff changeset	16 color,
25985 7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	17 config,
31526 6f150bb19317 templater: make pad() compute actual width Yuya Nishihara <yuya@tcha.org> parents: 31525 diff changeset	18 encoding,
25985 7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	19 error,
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	20 minirst,
34011 3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	21 obsutil,
25985 7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	22 parser,
30620 bb77654dc7ae py3: replace os.sep with pycompat.ossep (part 3 of 4) Pulkit Goyal <7895pulkit@gmail.com> parents: 30342 diff changeset	23 pycompat,
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	24 registrar,
25985 7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	25 revset as revsetmod,
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 30630 diff changeset	26 revsetlang,
25985 7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	27 templatefilters,
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	28 templatekw,
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	29 util,
7eb357b5f774 templater: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25815 diff changeset	30 )
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	31
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	32 # template parsing
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	33
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	34 elements = {
25815 e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	35 # token-type: binding-strength, primary, prefix, infix, suffix
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	36 "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
31884 0926ca37a990 templater: adjust binding strengths to make room for key-value operator Yuya Nishihara <yuya@tcha.org> parents: 31883 diff changeset	37 "%": (16, None, None, ("%", 16), None),
0926ca37a990 templater: adjust binding strengths to make room for key-value operator Yuya Nishihara <yuya@tcha.org> parents: 31883 diff changeset	38 "\|": (15, None, None, ("\|", 15), None),
0926ca37a990 templater: adjust binding strengths to make room for key-value operator Yuya Nishihara <yuya@tcha.org> parents: 31883 diff changeset	39 "": (5, None, None, ("", 5), None),
0926ca37a990 templater: adjust binding strengths to make room for key-value operator Yuya Nishihara <yuya@tcha.org> parents: 31883 diff changeset	40 "/": (5, None, None, ("/", 5), None),
0926ca37a990 templater: adjust binding strengths to make room for key-value operator Yuya Nishihara <yuya@tcha.org> parents: 31883 diff changeset	41 "+": (4, None, None, ("+", 4), None),
0926ca37a990 templater: adjust binding strengths to make room for key-value operator Yuya Nishihara <yuya@tcha.org> parents: 31883 diff changeset	42 "-": (4, None, ("negate", 19), ("-", 4), None),
31885 d18b624c1c06 templater: add parsing rule for key-value pair Yuya Nishihara <yuya@tcha.org> parents: 31884 diff changeset	43 "=": (3, None, None, ("keyvalue", 3), None),
31883 25be03a33f50 templater: sort token table by binding strength Yuya Nishihara <yuya@tcha.org> parents: 31880 diff changeset	44 ",": (2, None, None, ("list", 2), None),
25be03a33f50 templater: sort token table by binding strength Yuya Nishihara <yuya@tcha.org> parents: 31880 diff changeset	45 ")": (0, None, None, None, None),
25815 e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	46 "integer": (0, "integer", None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	47 "symbol": (0, "symbol", None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	48 "string": (0, "string", None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	49 "template": (0, "template", None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	50 "end": (0, None, None, None, None),
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	51 }
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	52
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	53 def tokenize(program, start, end, term=None):
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	54 """Parse a template expression into a stream of tokens, which must end
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	55 with term if specified"""
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	56 pos = start
32203 52e222eef646 py3: use pycompat.bytestr instead of bytes Pulkit Goyal <7895pulkit@gmail.com> parents: 32037 diff changeset	57 program = pycompat.bytestr(program)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	58 while pos < end:
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	59 c = program[pos]
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	60 if c.isspace(): # skip inter-token whitespace
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	61 pass
31885 d18b624c1c06 templater: add parsing rule for key-value pair Yuya Nishihara <yuya@tcha.org> parents: 31884 diff changeset	62 elif c in "(=,)%\|+-*/": # handle simple operators
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	63 yield (c, None, pos)
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	64 elif c in '"\'': # handle quoted templates
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	65 s = pos + 1
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	66 data, pos = _parsetemplate(program, s, end, c)
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	67 yield ('template', data, s)
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	68 pos -= 1
25784 33e613687dab templater: remove processing of "string" literals from tokenizer Yuya Nishihara <yuya@tcha.org> parents: 25783 diff changeset	69 elif c == 'r' and program[pos:pos + 2] in ("r'", 'r"'):
33e613687dab templater: remove processing of "string" literals from tokenizer Yuya Nishihara <yuya@tcha.org> parents: 25783 diff changeset	70 # handle quoted strings
33e613687dab templater: remove processing of "string" literals from tokenizer Yuya Nishihara <yuya@tcha.org> parents: 25783 diff changeset	71 c = program[pos + 1]
33e613687dab templater: remove processing of "string" literals from tokenizer Yuya Nishihara <yuya@tcha.org> parents: 25783 diff changeset	72 s = pos = pos + 2
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	73 while pos < end: # find closing quote
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	74 d = program[pos]
25638 6047b60cdd09 templater: fix handling of \-escapes in raw string literals Yuya Nishihara <yuya@tcha.org> parents: 25637 diff changeset	75 if d == '\\': # skip over escaped characters
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	76 pos += 2
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	77 continue
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	78 if d == c:
25785 f976b7dc5e7b templater: unify "string" and "rawstring" Yuya Nishihara <yuya@tcha.org> parents: 25784 diff changeset	79 yield ('string', program[s:pos], s)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	80 break
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	81 pos += 1
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	82 else:
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	83 raise error.ParseError(_("unterminated string"), s)
30115 8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	84 elif c.isdigit():
25002 829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	85 s = pos
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	86 while pos < end:
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	87 d = program[pos]
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	88 if not d.isdigit():
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	89 break
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	90 pos += 1
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	91 yield ('integer', program[s:pos], s)
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	92 pos -= 1
25676 ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	93 elif (c == '\\' and program[pos:pos + 2] in (r"\'", r'\"')
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	94 or c == 'r' and program[pos:pos + 3] in (r"r\'", r'r\"')):
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	95 # handle escaped quoted strings for compatibility with 2.9.2-3.4,
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	96 # where some of nested templates were preprocessed as strings and
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	97 # then compiled. therefore, \"...\" was allowed. (issue4733)
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	98 #
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	99 # processing flow of _evalifliteral() at 5ab28a2e9962:
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	100 # outer template string -> stringify() -> compiletemplate()
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	101 # ------------------------ ------------ ------------------
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	102 # {f("\\\\ {g(\"\\\"\")}"} \\ {g("\"")} [r'\\', {g("\"")}]
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	103 # ~~~~~~~~
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	104 # escaped quoted string
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	105 if c == 'r':
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	106 pos += 1
25785 f976b7dc5e7b templater: unify "string" and "rawstring" Yuya Nishihara <yuya@tcha.org> parents: 25784 diff changeset	107 token = 'string'
25676 ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	108 else:
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	109 token = 'template'
25676 ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	110 quote = program[pos:pos + 2]
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	111 s = pos = pos + 2
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	112 while pos < end: # find closing escaped quote
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	113 if program.startswith('\\\\\\', pos, end):
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	114 pos += 4 # skip over double escaped characters
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	115 continue
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	116 if program.startswith(quote, pos, end):
26215 72aad184f061 templater: create string unescape helper (issue4798) Matt Mackall <mpm@selenic.com> parents: 26197 diff changeset	117 # interpret as if it were a part of an outer string
26231 87c9c562c37a parser: move unescape helper from templater Yuya Nishihara <yuya@tcha.org> parents: 26215 diff changeset	118 data = parser.unescapestr(program[s:pos])
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	119 if token == 'template':
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	120 data = _parsetemplate(data, 0, len(data))[0]
25676 ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	121 yield (token, data, s)
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	122 pos += 1
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	123 break
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	124 pos += 1
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	125 else:
ec9c258e666d templater: parse \"...\" as string for 2.9.2-3.4 compatibility (issue4733) Yuya Nishihara <yuya@tcha.org> parents: 25638 diff changeset	126 raise error.ParseError(_("unterminated string"), s)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	127 elif c.isalnum() or c in '_':
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	128 s = pos
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	129 pos += 1
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	130 while pos < end: # find end of symbol
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	131 d = program[pos]
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	132 if not (d.isalnum() or d == "_"):
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	133 break
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	134 pos += 1
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	135 sym = program[s:pos]
18893 74ea61318ea8 templater: back out 0615b22da148, it breaks schemes ({1}) Brendan Cully <brendan@kublai.com> parents: 18889 diff changeset	136 yield ('symbol', sym, s)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	137 pos -= 1
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	138 elif c == term:
25782 babd2c93bd99 templater: check existence of closing brace of template string Yuya Nishihara <yuya@tcha.org> parents: 25781 diff changeset	139 yield ('end', None, pos + 1)
babd2c93bd99 templater: check existence of closing brace of template string Yuya Nishihara <yuya@tcha.org> parents: 25781 diff changeset	140 return
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	141 else:
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	142 raise error.ParseError(_("syntax error"), pos)
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	143 pos += 1
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	144 if term:
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	145 raise error.ParseError(_("unterminated template expansion"), start)
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	146 yield ('end', None, pos)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	147
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	148 def _parsetemplate(tmpl, start, stop, quote=''):
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	149 r"""
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	150 >>> _parsetemplate(b'foo{bar}"baz', 0, 12)
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	151 ([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12)
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	152 >>> _parsetemplate(b'foo{bar}"baz', 0, 12, quote=b'"')
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	153 ([('string', 'foo'), ('symbol', 'bar')], 9)
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	154 >>> _parsetemplate(b'foo"{bar}', 0, 9, quote=b'"')
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	155 ([('string', 'foo')], 4)
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	156 >>> _parsetemplate(br'foo\"bar"baz', 0, 12, quote=b'"')
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	157 ([('string', 'foo"'), ('string', 'bar')], 9)
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	158 >>> _parsetemplate(br'foo\\"bar', 0, 10, quote=b'"')
25785 f976b7dc5e7b templater: unify "string" and "rawstring" Yuya Nishihara <yuya@tcha.org> parents: 25784 diff changeset	159 ([('string', 'foo\\')], 6)
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	160 """
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	161 parsed = []
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	162 sepchars = '{' + quote
25781 82c918509ef5 templater: extract function that parses template string Yuya Nishihara <yuya@tcha.org> parents: 25780 diff changeset	163 pos = start
25654 af329a84310c parser: accept iterator of tokens instead of tokenizer function and program Yuya Nishihara <yuya@tcha.org> parents: 25599 diff changeset	164 p = parser.parser(elements)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	165 while pos < stop:
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	166 n = min((tmpl.find(c, pos, stop) for c in sepchars),
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	167 key=lambda n: (n < 0, n))
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	168 if n < 0:
26231 87c9c562c37a parser: move unescape helper from templater Yuya Nishihara <yuya@tcha.org> parents: 26215 diff changeset	169 parsed.append(('string', parser.unescapestr(tmpl[pos:stop])))
25780 8b900b937e1c templater: respect stop position while parsing template string Yuya Nishihara <yuya@tcha.org> parents: 25696 diff changeset	170 pos = stop
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	171 break
34088 f55769e41803 py3: use bytes[n:n + 1] to get bytes in templater._parsetemplate() Yuya Nishihara <yuya@tcha.org> parents: 34013 diff changeset	172 c = tmpl[n:n + 1]
24949 890845af1ac2 templater: strictly parse leading backslashes of '{' (issue4569) (BC) Yuya Nishihara <yuya@tcha.org> parents: 24948 diff changeset	173 bs = (n - pos) - len(tmpl[pos:n].rstrip('\\'))
25598 55c2cb65bdfa templater: drop strtoken argument from compiletemplate() Yuya Nishihara <yuya@tcha.org> parents: 25597 diff changeset	174 if bs % 2 == 1:
55c2cb65bdfa templater: drop strtoken argument from compiletemplate() Yuya Nishihara <yuya@tcha.org> parents: 25597 diff changeset	175 # escaped (e.g. '\{', '\\\{', but not '\\{')
26231 87c9c562c37a parser: move unescape helper from templater Yuya Nishihara <yuya@tcha.org> parents: 26215 diff changeset	176 parsed.append(('string', parser.unescapestr(tmpl[pos:n - 1]) + c))
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	177 pos = n + 1
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	178 continue
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	179 if n > pos:
26231 87c9c562c37a parser: move unescape helper from templater Yuya Nishihara <yuya@tcha.org> parents: 26215 diff changeset	180 parsed.append(('string', parser.unescapestr(tmpl[pos:n])))
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	181 if c == quote:
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	182 return parsed, n + 1
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	183
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	184 parseres, pos = p.parse(tokenize(tmpl, n + 1, stop, '}'))
13665 e798e430c5e5 revset: report a parse error if a revset is not parsed completely (issue2654) Bernhard Leiner <bleiner@gmail.com> parents: 13187 diff changeset	185 parsed.append(parseres)
25783 1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	186
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	187 if quote:
1f6878c87c25 templater: introduce one-pass parsing of nested template strings Yuya Nishihara <yuya@tcha.org> parents: 25782 diff changeset	188 raise error.ParseError(_("unterminated string"), start)
25781 82c918509ef5 templater: extract function that parses template string Yuya Nishihara <yuya@tcha.org> parents: 25780 diff changeset	189 return parsed, pos
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	190
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	191 def _unnesttemplatelist(tree):
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	192 """Expand list of templates to node tuple
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	193
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	194 >>> def f(tree):
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	195 ... print(pycompat.sysstr(prettyformat(_unnesttemplatelist(tree))))
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	196 >>> f((b'template', []))
34090 7bbc4e113e5f parser: stabilize output of prettyformat() by using byte-safe repr() Yuya Nishihara <yuya@tcha.org> parents: 34088 diff changeset	197 (string '')
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	198 >>> f((b'template', [(b'string', b'foo')]))
34090 7bbc4e113e5f parser: stabilize output of prettyformat() by using byte-safe repr() Yuya Nishihara <yuya@tcha.org> parents: 34088 diff changeset	199 (string 'foo')
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	200 >>> f((b'template', [(b'string', b'foo'), (b'symbol', b'rev')]))
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	201 (template
34090 7bbc4e113e5f parser: stabilize output of prettyformat() by using byte-safe repr() Yuya Nishihara <yuya@tcha.org> parents: 34088 diff changeset	202 (string 'foo')
7bbc4e113e5f parser: stabilize output of prettyformat() by using byte-safe repr() Yuya Nishihara <yuya@tcha.org> parents: 34088 diff changeset	203 (symbol 'rev'))
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	204 >>> f((b'template', [(b'symbol', b'rev')])) # template(rev) -> str
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	205 (template
34090 7bbc4e113e5f parser: stabilize output of prettyformat() by using byte-safe repr() Yuya Nishihara <yuya@tcha.org> parents: 34088 diff changeset	206 (symbol 'rev'))
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	207 >>> f((b'template', [(b'template', [(b'string', b'foo')])]))
34090 7bbc4e113e5f parser: stabilize output of prettyformat() by using byte-safe repr() Yuya Nishihara <yuya@tcha.org> parents: 34088 diff changeset	208 (string 'foo')
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	209 """
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	210 if not isinstance(tree, tuple):
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	211 return tree
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	212 op = tree[0]
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	213 if op != 'template':
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	214 return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:])
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	215
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	216 assert len(tree) == 2
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	217 xs = tuple(_unnesttemplatelist(x) for x in tree[1])
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	218 if not xs:
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	219 return ('string', '') # empty template ""
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	220 elif len(xs) == 1 and xs[0][0] == 'string':
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	221 return xs[0] # fast path for string with no template fragment "x"
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	222 else:
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	223 return (op,) + xs
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	224
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	225 def parse(tmpl):
1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	226 """Parse template string into tree"""
25781 82c918509ef5 templater: extract function that parses template string Yuya Nishihara <yuya@tcha.org> parents: 25780 diff changeset	227 parsed, pos = _parsetemplate(tmpl, 0, len(tmpl))
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	228 assert pos == len(tmpl), 'unquoted template should be consumed'
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	229 return _unnesttemplatelist(('template', parsed))
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	230
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	231 def _parseexpr(expr):
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	232 """Parse a template expression into tree
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	233
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	234 >>> _parseexpr(b'"foo"')
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	235 ('string', 'foo')
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	236 >>> _parseexpr(b'foo(bar)')
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	237 ('func', ('symbol', 'foo'), ('symbol', 'bar'))
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	238 >>> _parseexpr(b'foo(')
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	239 Traceback (most recent call last):
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	240 ...
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	241 ParseError: ('not a prefix: end', 4)
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	242 >>> _parseexpr(b'"foo" "bar"')
28911 35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	243 Traceback (most recent call last):
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	244 ...
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	245 ParseError: ('invalid token', 7)
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	246 """
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	247 p = parser.parser(elements)
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	248 tree, pos = p.parse(tokenize(expr, 0, len(expr)))
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	249 if pos != len(expr):
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	250 raise error.ParseError(_('invalid token'), pos)
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	251 return _unnesttemplatelist(tree)
35da19348143 templater: add function to parse whole string as template expression Yuya Nishihara <yuya@tcha.org> parents: 28837 diff changeset	252
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	253 def prettyformat(tree):
73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	254 return parser.prettyformat(tree, ('integer', 'string', 'symbol'))
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	255
25001 9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	256 def compileexp(exp, context, curmethods):
28956 eea98190ed73 templater: inline compiletemplate() function into engine Yuya Nishihara <yuya@tcha.org> parents: 28954 diff changeset	257 """Compile parsed template tree to (func, data) pair"""
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	258 t = exp[0]
25001 9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	259 if t in curmethods:
9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	260 return curmethods[t](exp, context)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	261 raise error.ParseError(_("unknown method '%s'") % t)
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	262
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	263 # template evaluation
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	264
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	265 def getsymbol(exp):
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	266 if exp[0] == 'symbol':
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	267 return exp[1]
21822 028a48105191 templater: add symbol to error Ryan McElroy <rmcelroy@fb.com> parents: 21821 diff changeset	268 raise error.ParseError(_("expected a symbol, got '%s'") % exp[0])
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	269
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	270 def getlist(x):
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	271 if not x:
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	272 return []
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	273 if x[0] == 'list':
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	274 return getlist(x[1]) + [x[2]]
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	275 return [x]
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	276
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	277 def gettemplate(exp, context):
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	278 """Compile given template tree or load named template from map file;
1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	279 returns (func, data) pair"""
28546 1987ed32efca templater: relax type of mapped template Yuya Nishihara <yuya@tcha.org> parents: 28545 diff changeset	280 if exp[0] in ('template', 'string'):
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	281 return compileexp(exp, context, methods)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	282 if exp[0] == 'symbol':
25599 695b93a79d17 templater: comment that gettemplate() has different name resolution order Yuya Nishihara <yuya@tcha.org> parents: 25598 diff changeset	283 # unlike runsymbol(), here 'symbol' is always taken as template name
695b93a79d17 templater: comment that gettemplate() has different name resolution order Yuya Nishihara <yuya@tcha.org> parents: 25598 diff changeset	284 # even if it exists in mapping. this allows us to override mapping
695b93a79d17 templater: comment that gettemplate() has different name resolution order Yuya Nishihara <yuya@tcha.org> parents: 25598 diff changeset	285 # by web templates, e.g. 'changelogtag' is redefined in map file.
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	286 return context._load(exp[1])
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	287 raise error.ParseError(_("expected template specifier"))
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	288
31927 2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	289 def findsymbolicname(arg):
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	290 """Find symbolic name for the given compiled expression; returns None
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	291 if nothing found reliably"""
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	292 while True:
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	293 func, data = arg
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	294 if func is runsymbol:
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	295 return data
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	296 elif func is runfilter:
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	297 arg = data[0]
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	298 else:
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	299 return None
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	300
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	301 def evalrawexp(context, mapping, arg):
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	302 """Evaluate given argument as a bare template object which may require
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	303 further processing (such as folding generator of strings)"""
26124 604a7c941103 templater: extract helper that evaluates filter or function argument Yuya Nishihara <yuya@tcha.org> parents: 26106 diff changeset	304 func, data = arg
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	305 return func(context, mapping, data)
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	306
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	307 def evalfuncarg(context, mapping, arg):
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	308 """Evaluate given argument as value type"""
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	309 thing = evalrawexp(context, mapping, arg)
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	310 # evalrawexp() may return string, generator of strings or arbitrary object
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	311 # such as date tuple, but filter does not want generator.
26124 604a7c941103 templater: extract helper that evaluates filter or function argument Yuya Nishihara <yuya@tcha.org> parents: 26106 diff changeset	312 if isinstance(thing, types.GeneratorType):
604a7c941103 templater: extract helper that evaluates filter or function argument Yuya Nishihara <yuya@tcha.org> parents: 26106 diff changeset	313 thing = stringify(thing)
604a7c941103 templater: extract helper that evaluates filter or function argument Yuya Nishihara <yuya@tcha.org> parents: 26106 diff changeset	314 return thing
604a7c941103 templater: extract helper that evaluates filter or function argument Yuya Nishihara <yuya@tcha.org> parents: 26106 diff changeset	315
29827 034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	316 def evalboolean(context, mapping, arg):
29828 cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	317 """Evaluate given argument as boolean, but also takes boolean literals"""
29827 034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	318 func, data = arg
29828 cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	319 if func is runsymbol:
cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	320 thing = func(context, mapping, data, default=None)
cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	321 if thing is None:
cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	322 # not a template keyword, takes as a boolean literal
cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	323 thing = util.parsebool(data)
cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	324 else:
cc11079644fc templater: make pad() evaluate boolean argument (BC) Yuya Nishihara <yuya@tcha.org> parents: 29827 diff changeset	325 thing = func(context, mapping, data)
29827 034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	326 if isinstance(thing, bool):
034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	327 return thing
034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	328 # other objects are evaluated as strings, which means 0 is True, but
034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	329 # empty dict/list should be False as they are expected to be ''
034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	330 return bool(stringify(thing))
034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	331
28343 a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	332 def evalinteger(context, mapping, arg, err):
28344 ac371d4c007f templater: drop redundant type conversion when evaluating integer argument Yuya Nishihara <yuya@tcha.org> parents: 28343 diff changeset	333 v = evalfuncarg(context, mapping, arg)
28343 a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	334 try:
28344 ac371d4c007f templater: drop redundant type conversion when evaluating integer argument Yuya Nishihara <yuya@tcha.org> parents: 28343 diff changeset	335 return int(v)
ac371d4c007f templater: drop redundant type conversion when evaluating integer argument Yuya Nishihara <yuya@tcha.org> parents: 28343 diff changeset	336 except (TypeError, ValueError):
28343 a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	337 raise error.ParseError(err)
a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	338
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	339 def evalstring(context, mapping, arg):
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	340 return stringify(evalrawexp(context, mapping, arg))
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	341
28373 9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	342 def evalstringliteral(context, mapping, arg):
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	343 """Evaluate given argument as string template, but returns symbol name
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	344 if it is unknown"""
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	345 func, data = arg
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	346 if func is runsymbol:
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	347 thing = func(context, mapping, data, default=data)
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	348 else:
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	349 thing = func(context, mapping, data)
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	350 return stringify(thing)
9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	351
25002 829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	352 def runinteger(context, mapping, data):
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	353 return int(data)
829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	354
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	355 def runstring(context, mapping, data):
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	356 return data
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	357
27939 7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	358 def _recursivesymbolblocker(key):
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	359 def showrecursion(**args):
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	360 raise error.Abort(_("recursive reference '%s' in template") % key)
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	361 return showrecursion
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	362
27940 cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	363 def _runrecursivesymbol(context, mapping, key):
cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	364 raise error.Abort(_("recursive reference '%s' in template") % key)
cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	365
28373 9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	366 def runsymbol(context, mapping, key, default=''):
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	367 v = mapping.get(key)
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	368 if v is None:
19770 0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	369 v = context._defaults.get(key)
0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	370 if v is None:
27939 7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	371 # put poison to cut recursion. we can't move this to parsing phase
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	372 # because "x = {x}" is allowed if "x" is a keyword. (issue4758)
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	373 safemapping = mapping.copy()
7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	374 safemapping[key] = _recursivesymbolblocker(key)
19770 0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	375 try:
27939 7ed3a3c0cef1 templater: abort if infinite recursion detected while evaluation (issue4758) Yuya Nishihara <yuya@tcha.org> parents: 27892 diff changeset	376 v = context.process(key, safemapping)
19770 0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	377 except TemplateNotFound:
28373 9a9dd71e882c templater: make label() take unknown symbol as color literal Yuya Nishihara <yuya@tcha.org> parents: 28349 diff changeset	378 v = default
21798 f2c617ff2abc templater: restore use of callable() since it was readded in Python 3.2 Augie Fackler <raf@durin42.com> parents: 21540 diff changeset	379 if callable(v):
33033 c31d45623304 py3: convert kwargs' keys' to str using pycompat.strkwargs() Pulkit Goyal <7895pulkit@gmail.com> parents: 33032 diff changeset	380 return v(**pycompat.strkwargs(mapping))
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	381 return v
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	382
25596 c1975809a6b5 templater: take any string literals as template, but not for rawstring (BC) Yuya Nishihara <yuya@tcha.org> parents: 25595 diff changeset	383 def buildtemplate(exp, context):
28547 73d01cba5810 templater: expand list of parsed templates to template node Yuya Nishihara <yuya@tcha.org> parents: 28546 diff changeset	384 ctmpl = [compileexp(e, context, methods) for e in exp[1:]]
25596 c1975809a6b5 templater: take any string literals as template, but not for rawstring (BC) Yuya Nishihara <yuya@tcha.org> parents: 25595 diff changeset	385 return (runtemplate, ctmpl)
c1975809a6b5 templater: take any string literals as template, but not for rawstring (BC) Yuya Nishihara <yuya@tcha.org> parents: 25595 diff changeset	386
25595 a7dd6692e5cb templater: move runtemplate function out of buildmap/runmap pair Yuya Nishihara <yuya@tcha.org> parents: 25580 diff changeset	387 def runtemplate(context, mapping, template):
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	388 for arg in template:
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	389 yield evalrawexp(context, mapping, arg)
25595 a7dd6692e5cb templater: move runtemplate function out of buildmap/runmap pair Yuya Nishihara <yuya@tcha.org> parents: 25580 diff changeset	390
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	391 def buildfilter(exp, context):
26104 0f1bc7faa50d templater: inline getfilter() to buildfilter() Yuya Nishihara <yuya@tcha.org> parents: 25985 diff changeset	392 n = getsymbol(exp[2])
0f1bc7faa50d templater: inline getfilter() to buildfilter() Yuya Nishihara <yuya@tcha.org> parents: 25985 diff changeset	393 if n in context._filters:
0f1bc7faa50d templater: inline getfilter() to buildfilter() Yuya Nishihara <yuya@tcha.org> parents: 25985 diff changeset	394 filt = context._filters[n]
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	395 arg = compileexp(exp[1], context, methods)
26125 c990afab2243 templater: drop unneeded destructuring of argument tuple at buildfilter Yuya Nishihara <yuya@tcha.org> parents: 26124 diff changeset	396 return (runfilter, (arg, filt))
26105 d67341f55429 templater: introduce unified filter syntax for unary functions Yuya Nishihara <yuya@tcha.org> parents: 26104 diff changeset	397 if n in funcs:
d67341f55429 templater: introduce unified filter syntax for unary functions Yuya Nishihara <yuya@tcha.org> parents: 26104 diff changeset	398 f = funcs[n]
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	399 args = _buildfuncargs(exp[1], context, methods, n, f._argspec)
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	400 return (f, args)
26104 0f1bc7faa50d templater: inline getfilter() to buildfilter() Yuya Nishihara <yuya@tcha.org> parents: 25985 diff changeset	401 raise error.ParseError(_("unknown function '%s'") % n)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	402
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	403 def runfilter(context, mapping, data):
26125 c990afab2243 templater: drop unneeded destructuring of argument tuple at buildfilter Yuya Nishihara <yuya@tcha.org> parents: 26124 diff changeset	404 arg, filt = data
c990afab2243 templater: drop unneeded destructuring of argument tuple at buildfilter Yuya Nishihara <yuya@tcha.org> parents: 26124 diff changeset	405 thing = evalfuncarg(context, mapping, arg)
17383 099c778ceb33 templater: abort when a template filter raises an exception (issue2987) Neil Kodner <neilk@fb.com> parents: 17334 diff changeset	406 try:
24280 6c55e37ba5f2 templater: allow piping generator-type function output to filters Yuya Nishihara <yuya@tcha.org> parents: 24240 diff changeset	407 return filt(thing)
17383 099c778ceb33 templater: abort when a template filter raises an exception (issue2987) Neil Kodner <neilk@fb.com> parents: 17334 diff changeset	408 except (ValueError, AttributeError, TypeError):
31927 2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	409 sym = findsymbolicname(arg)
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	410 if sym:
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	411 msg = (_("template filter '%s' is not compatible with keyword '%s'")
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	412 % (filt.func_name, sym))
17383 099c778ceb33 templater: abort when a template filter raises an exception (issue2987) Neil Kodner <neilk@fb.com> parents: 17334 diff changeset	413 else:
31927 2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	414 msg = _("incompatible use of template filter '%s'") % filt.func_name
2abc556dbe92 templater: find keyword name more thoroughly on filtering error Yuya Nishihara <yuya@tcha.org> parents: 31926 diff changeset	415 raise error.Abort(msg)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	416
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	417 def buildmap(exp, context):
34332 86d050abd5c1 templater: do not destructure operands in buildmap() Yuya Nishihara <yuya@tcha.org> parents: 34331 diff changeset	418 darg = compileexp(exp[1], context, methods)
86d050abd5c1 templater: do not destructure operands in buildmap() Yuya Nishihara <yuya@tcha.org> parents: 34331 diff changeset	419 targ = gettemplate(exp[2], context)
86d050abd5c1 templater: do not destructure operands in buildmap() Yuya Nishihara <yuya@tcha.org> parents: 34331 diff changeset	420 return (runmap, (darg, targ))
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	421
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	422 def runmap(context, mapping, data):
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	423 darg, targ = data
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	424 d = evalrawexp(context, mapping, darg)
27891 ac8c0ee5c3b8 templater: make _hybrid not callable to avoid conflicting semantics Yuya Nishihara <yuya@tcha.org> parents: 27637 diff changeset	425 if util.safehasattr(d, 'itermaps'):
28349 7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	426 diter = d.itermaps()
7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	427 else:
7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	428 try:
7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	429 diter = iter(d)
7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	430 except TypeError:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	431 sym = findsymbolicname(darg)
34331 e473f482b9b3 templater: use helper function to get name of non-iterable keyword Yuya Nishihara <yuya@tcha.org> parents: 34294 diff changeset	432 if sym:
e473f482b9b3 templater: use helper function to get name of non-iterable keyword Yuya Nishihara <yuya@tcha.org> parents: 34294 diff changeset	433 raise error.ParseError(_("keyword '%s' is not iterable") % sym)
28349 7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	434 else:
7cb2f2438f85 templater: handle exception when applying map operator to non-iterable object Yuya Nishihara <yuya@tcha.org> parents: 28348 diff changeset	435 raise error.ParseError(_("%r is not iterable") % d)
17631 0b241d7a8c62 templating: make new-style templating features work with command line lists Matt Mackall <mpm@selenic.com> parents: 17383 diff changeset	436
31807 e6eb86b154c5 templater: provide loop counter as "index" keyword Yuya Nishihara <yuya@tcha.org> parents: 31806 diff changeset	437 for i, v in enumerate(diter):
28225 5c11702fe2a3 templater: fix list templating bug Kostia Balytskyi <ikostia@fb.com> parents: 28178 diff changeset	438 lm = mapping.copy()
31807 e6eb86b154c5 templater: provide loop counter as "index" keyword Yuya Nishihara <yuya@tcha.org> parents: 31806 diff changeset	439 lm['index'] = i
31806 8f203b491bb5 templater: rename variable "i" to "v" in runmap() Yuya Nishihara <yuya@tcha.org> parents: 31527 diff changeset	440 if isinstance(v, dict):
8f203b491bb5 templater: rename variable "i" to "v" in runmap() Yuya Nishihara <yuya@tcha.org> parents: 31527 diff changeset	441 lm.update(v)
17991 d605a82cf189 hgweb: display diff for a changeset against any parents (issue2810) Weiwen <weiwen@fb.com> parents: 17982 diff changeset	442 lm['originalnode'] = mapping.get('node')
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	443 yield evalrawexp(context, lm, targ)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	444 else:
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	445 # v is not an iterable of dicts, this happen when 'key'
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	446 # has been fully expanded already and format is useless.
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	447 # If so, return the expanded value.
31806 8f203b491bb5 templater: rename variable "i" to "v" in runmap() Yuya Nishihara <yuya@tcha.org> parents: 31527 diff changeset	448 yield v
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	449
30115 8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	450 def buildnegate(exp, context):
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	451 arg = compileexp(exp[1], context, exprmethods)
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	452 return (runnegate, arg)
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	453
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	454 def runnegate(context, mapping, data):
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	455 data = evalinteger(context, mapping, data,
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	456 _('negation needs an integer argument'))
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	457 return -data
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	458
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	459 def buildarithmetic(exp, context, func):
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	460 left = compileexp(exp[1], context, exprmethods)
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	461 right = compileexp(exp[2], context, exprmethods)
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	462 return (runarithmetic, (func, left, right))
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	463
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	464 def runarithmetic(context, mapping, data):
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	465 func, left, right = data
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	466 left = evalinteger(context, mapping, left,
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	467 _('arithmetic only defined on integers'))
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	468 right = evalinteger(context, mapping, right,
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	469 _('arithmetic only defined on integers'))
30116 1c01fa29630f templater: handle division by zero in arithmetic Simon Farnsworth <simonfar@fb.com> parents: 30115 diff changeset	470 try:
1c01fa29630f templater: handle division by zero in arithmetic Simon Farnsworth <simonfar@fb.com> parents: 30115 diff changeset	471 return func(left, right)
1c01fa29630f templater: handle division by zero in arithmetic Simon Farnsworth <simonfar@fb.com> parents: 30115 diff changeset	472 except ZeroDivisionError:
1c01fa29630f templater: handle division by zero in arithmetic Simon Farnsworth <simonfar@fb.com> parents: 30115 diff changeset	473 raise error.Abort(_('division by zero is not defined'))
30115 8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	474
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	475 def buildfunc(exp, context):
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	476 n = getsymbol(exp[1])
14925 ab545a15d807 templater: use a global funcs table Matt Mackall <mpm@selenic.com> parents: 14168 diff changeset	477 if n in funcs:
ab545a15d807 templater: use a global funcs table Matt Mackall <mpm@selenic.com> parents: 14168 diff changeset	478 f = funcs[n]
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	479 args = _buildfuncargs(exp[2], context, exprmethods, n, f._argspec)
14925 ab545a15d807 templater: use a global funcs table Matt Mackall <mpm@selenic.com> parents: 14168 diff changeset	480 return (f, args)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	481 if n in context._filters:
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	482 args = _buildfuncargs(exp[2], context, exprmethods, n, argspec=None)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	483 if len(args) != 1:
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	484 raise error.ParseError(_("filter %s expects one argument") % n)
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	485 f = context._filters[n]
26125 c990afab2243 templater: drop unneeded destructuring of argument tuple at buildfilter Yuya Nishihara <yuya@tcha.org> parents: 26124 diff changeset	486 return (runfilter, (args[0], f))
20857 6eb55310fcbc templater: raise error for unknown func Sean Farley <sean.michael.farley@gmail.com> parents: 20663 diff changeset	487 raise error.ParseError(_("unknown function '%s'") % n)
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	488
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	489 def _buildfuncargs(exp, context, curmethods, funcname, argspec):
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	490 """Compile parsed tree of function arguments into list or dict of
31921 2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	491 (func, data) pairs
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	492
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	493 >>> context = engine(lambda t: (runsymbol, t))
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	494 >>> def fargs(expr, argspec):
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	495 ... x = _parseexpr(expr)
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	496 ... n = getsymbol(x[1])
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	497 ... return _buildfuncargs(x[2], context, exprmethods, n, argspec)
34154 be00af4a1ac5 doctest: coerce dict.keys() to list Yuya Nishihara <yuya@tcha.org> parents: 34152 diff changeset	498 >>> list(fargs(b'a(l=1, k=2)', b'k l m').keys())
31922 0f41f1e3c75c parser: preserve order of keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31921 diff changeset	499 ['l', 'k']
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 34090 diff changeset	500 >>> args = fargs(b'a(opts=1, k=2)', b'**opts')
34154 be00af4a1ac5 doctest: coerce dict.keys() to list Yuya Nishihara <yuya@tcha.org> parents: 34152 diff changeset	501 >>> list(args.keys()), list(args[b'opts'].keys())
31922 0f41f1e3c75c parser: preserve order of keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31921 diff changeset	502 (['opts'], ['opts', 'k'])
31921 2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	503 """
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	504 def compiledict(xs):
31922 0f41f1e3c75c parser: preserve order of keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31921 diff changeset	505 return util.sortdict((k, compileexp(x, context, curmethods))
0f41f1e3c75c parser: preserve order of keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31921 diff changeset	506 for k, x in xs.iteritems())
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	507 def compilelist(xs):
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	508 return [compileexp(x, context, curmethods) for x in xs]
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	509
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	510 if not argspec:
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	511 # filter or function with no argspec: return list of positional args
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	512 return compilelist(getlist(exp))
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	513
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	514 # function with argspec: return dict of named args
31921 2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	515 _poskeys, varkey, _keys, optkey = argspec = parser.splitargspec(argspec)
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	516 treeargs = parser.buildargsdict(getlist(exp), funcname, argspec,
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	517 keyvaluenode='keyvalue', keynode='symbol')
31922 0f41f1e3c75c parser: preserve order of keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31921 diff changeset	518 compargs = util.sortdict()
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	519 if varkey:
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	520 compargs[varkey] = compilelist(treeargs.pop(varkey))
31921 2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	521 if optkey:
2156934b7917 parser: extend buildargsdict() to support arbitrary number of *kwargs Yuya Nishihara <yuya@tcha.org>* parents: 31887 diff changeset	522 compargs[optkey] = compiledict(treeargs.pop(optkey))
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	523 compargs.update(compiledict(treeargs))
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	524 return compargs
bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	525
31885 d18b624c1c06 templater: add parsing rule for key-value pair Yuya Nishihara <yuya@tcha.org> parents: 31884 diff changeset	526 def buildkeyvaluepair(exp, content):
d18b624c1c06 templater: add parsing rule for key-value pair Yuya Nishihara <yuya@tcha.org> parents: 31884 diff changeset	527 raise error.ParseError(_("can't use a key-value pair in this context"))
d18b624c1c06 templater: add parsing rule for key-value pair Yuya Nishihara <yuya@tcha.org> parents: 31884 diff changeset	528
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	529 # 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	530 funcs = {}
efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	531
efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	532 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	533
efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	534 @templatefunc('date(date[, fmt])')
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	535 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	536 """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	537 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	538 "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	539 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	540 # i18n: "date" is a keyword
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	541 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	542
28334 9dc340f51e06 templater: make date() use helper function to evaluate argument Yuya Nishihara <yuya@tcha.org> parents: 28333 diff changeset	543 date = evalfuncarg(context, mapping, args[0])
24903 09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	544 fmt = None
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	545 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	546 fmt = evalstring(context, mapping, args[1])
24903 09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	547 try:
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	548 if fmt is None:
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	549 return util.datestr(date)
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	550 else:
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	551 return util.datestr(date, fmt)
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	552 except (TypeError, ValueError):
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	553 # i18n: "date" is a keyword
09124cce913f templater: fix crash by passing invalid object to date() function Yuya Nishihara <yuya@tcha.org> parents: 24886 diff changeset	554 raise error.ParseError(_("date expects a date information"))
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	555
31928 277b3e2d711b templater: add shorthand for building a dict like {"key": key} Yuya Nishihara <yuya@tcha.org> parents: 31927 diff changeset	556 @templatefunc('dict([[key=]value...])', argspec='args *kwargs')
31926 932241b8c644 templater: add dict() constructor Yuya Nishihara <yuya@tcha.org> parents: 31922 diff changeset	557 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	558 """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	559 a value expression can provide an unambiguous name."""
31926 932241b8c644 templater: add dict() constructor Yuya Nishihara <yuya@tcha.org> parents: 31922 diff changeset	560 data = util.sortdict()
31928 277b3e2d711b templater: add shorthand for building a dict like {"key": key} Yuya Nishihara <yuya@tcha.org> parents: 31927 diff changeset	561
277b3e2d711b templater: add shorthand for building a dict like {"key": key} Yuya Nishihara <yuya@tcha.org> parents: 31927 diff changeset	562 for v in args['args']:
277b3e2d711b templater: add shorthand for building a dict like {"key": key} Yuya Nishihara <yuya@tcha.org> parents: 31927 diff changeset	563 k = findsymbolicname(v)
277b3e2d711b templater: add shorthand for building a dict like {"key": key} Yuya Nishihara <yuya@tcha.org> parents: 31927 diff changeset	564 if not k:
277b3e2d711b templater: add shorthand for building a dict like {"key": key} Yuya Nishihara <yuya@tcha.org> parents: 31927 diff changeset	565 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	566 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	567 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	568 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	569
31926 932241b8c644 templater: add dict() constructor Yuya Nishihara <yuya@tcha.org> parents: 31922 diff changeset	570 data.update((k, evalfuncarg(context, mapping, v))
932241b8c644 templater: add dict() constructor Yuya Nishihara <yuya@tcha.org> parents: 31922 diff changeset	571 for k, v in args['kwargs'].iteritems())
932241b8c644 templater: add dict() constructor Yuya Nishihara <yuya@tcha.org> parents: 31922 diff changeset	572 return templatekw.hybriddict(data)
932241b8c644 templater: add dict() constructor Yuya Nishihara <yuya@tcha.org> parents: 31922 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('diff([includepattern [, excludepattern]])')
22434 40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	575 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	576 """Show a diff, optionally
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	577 specifying files to include or exclude."""
22434 40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	578 if len(args) > 2:
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	579 # i18n: "diff" is a keyword
27293 9e06e7fb037d grammar: favor zero, one, two over ... or no timeless <timeless@mozdev.org> parents: 26587 diff changeset	580 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	581
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	582 def getpatterns(i):
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	583 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	584 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	585 if s:
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	586 return [s]
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	587 return []
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	588
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	589 ctx = mapping['ctx']
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	590 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	591
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	592 return ''.join(chunks)
40ce05b50148 templater: add "diff" template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22304 diff changeset	593
30012 e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	594 @templatefunc('files(pattern)')
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	595 def files(context, mapping, args):
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	596 """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: 29858 diff changeset	597 :hg:`help patterns`."""
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	598 if not len(args) == 1:
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	599 # i18n: "files" is a keyword
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	600 raise error.ParseError(_("files expects one argument"))
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	601
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	602 raw = evalstring(context, mapping, args[0])
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	603 ctx = mapping['ctx']
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	604 m = ctx.match([raw])
e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	605 files = list(ctx.matches(m))
32037 e5eab0fe69ee templatekw: have showlist() take mapping dict with no *kwargs expansion (API) Yuya Nishihara <yuya@tcha.org>* parents: 31928 diff changeset	606 return templatekw.showlist("file", files, mapping)
30012 e83f89d3b1f7 templates: add built-in files() function Hannes Oldenburg <hannes.christian.oldenburg@gmail.com> parents: 29858 diff changeset	607
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	608 @templatefunc('fill(text[, width[, initialident[, hangindent]]])')
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	609 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	610 """Fill many
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	611 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	612 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	613 # i18n: "fill" is a keyword
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	614 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	615
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	616 text = evalstring(context, mapping, args[0])
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	617 width = 76
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	618 initindent = ''
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	619 hangindent = ''
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	620 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	621 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	622 # i18n: "fill" is a keyword
a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	623 _("fill expects an integer width"))
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	624 try:
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	625 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	626 hangindent = evalstring(context, mapping, args[3])
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	627 except IndexError:
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	628 pass
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	629
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	630 return templatefilters.fill(text, width, initindent, hangindent)
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	631
31179 48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	632 @templatefunc('formatnode(node)')
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	633 def formatnode(context, mapping, args):
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	634 """Obtain the preferred form of a changeset hash. (DEPRECATED)"""
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	635 if len(args) != 1:
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	636 # i18n: "formatnode" is a keyword
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	637 raise error.ParseError(_("formatnode expects one argument"))
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	638
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	639 ui = mapping['ui']
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	640 node = evalstring(context, mapping, args[0])
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	641 if ui.debugflag:
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	642 return node
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	643 return templatefilters.short(node)
48a8b2e5fe31 templater: port formatnode filter from changeset_templater Yuya Nishihara <yuya@tcha.org> parents: 31044 diff changeset	644
31887 f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	645 @templatefunc('pad(text, width[, fillchar=\' \'[, left=False]])',
f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	646 argspec='text width fillchar left')
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	647 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	648 """Pad text with a
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	649 fill character."""
31887 f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	650 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	651 # i18n: "pad" is a keyword
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	652 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	653
31887 f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	654 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	655 # 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	656 _("pad() expects an integer width"))
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	657
31887 f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	658 text = evalstring(context, mapping, args['text'])
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	659
29829 407879b0893b templater: rename "right" argument of pad() function Yuya Nishihara <yuya@tcha.org> parents: 29828 diff changeset	660 left = False
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	661 fillchar = ' '
31887 f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	662 if 'fillchar' in args:
f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	663 fillchar = evalstring(context, mapping, args['fillchar'])
31527 44c591f63458 templater: make pad() strip color codes before computing width (issue5416) Yuya Nishihara <yuya@tcha.org> parents: 31526 diff changeset	664 if len(color.stripeffects(fillchar)) != 1:
31525 3725986b151a templater: reject bad fillchar argument passed to pad() Yuya Nishihara <yuya@tcha.org> parents: 31179 diff changeset	665 # i18n: "pad" is a keyword
3725986b151a templater: reject bad fillchar argument passed to pad() Yuya Nishihara <yuya@tcha.org> parents: 31179 diff changeset	666 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	667 if 'left' in args:
f7b3677f66cd templater: port pad() to take keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31886 diff changeset	668 left = evalboolean(context, mapping, args['left'])
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	669
31527 44c591f63458 templater: make pad() strip color codes before computing width (issue5416) Yuya Nishihara <yuya@tcha.org> parents: 31526 diff changeset	670 fillwidth = width - encoding.colwidth(color.stripeffects(text))
31526 6f150bb19317 templater: make pad() compute actual width Yuya Nishihara <yuya@tcha.org> parents: 31525 diff changeset	671 if fillwidth <= 0:
6f150bb19317 templater: make pad() compute actual width Yuya Nishihara <yuya@tcha.org> parents: 31525 diff changeset	672 return text
29829 407879b0893b templater: rename "right" argument of pad() function Yuya Nishihara <yuya@tcha.org> parents: 29828 diff changeset	673 if left:
31526 6f150bb19317 templater: make pad() compute actual width Yuya Nishihara <yuya@tcha.org> parents: 31525 diff changeset	674 return fillchar * fillwidth + text
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	675 else:
31526 6f150bb19317 templater: make pad() compute actual width Yuya Nishihara <yuya@tcha.org> parents: 31525 diff changeset	676 return text + fillchar * fillwidth
20370 aa51392da507 template: add pad function for padding output Durham Goode <durham@fb.com> parents: 20369 diff changeset	677
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	678 @templatefunc('indent(text, indentchars[, firstline])')
25489 ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	679 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	680 """Indents all non-empty lines
25489 ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	681 with the characters given in the indentchars string. An optional
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	682 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	683 if present."""
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	684 if not (2 <= len(args) <= 3):
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	685 # i18n: "indent" is a keyword
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	686 raise error.ParseError(_("indent() expects two or three arguments"))
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	687
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	688 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	689 indent = evalstring(context, mapping, args[1])
25489 ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	690
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	691 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	692 firstline = evalstring(context, mapping, args[2])
25489 ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	693 else:
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	694 firstline = indent
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	695
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	696 # 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	697 return templatefilters.indent(firstline + text, indent)
ef8956aa8755 templater: introduce indent function Ryan McElroy <rmcelroy@fb.com> parents: 25096 diff changeset	698
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	699 @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	700 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	701 """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	702 are complex types. This function allows you to obtain the value of an
26197 fb6c08a9b40a templater: fix get English timeless@mozdev.org parents: 26188 diff changeset	703 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	704 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	705 # 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	706 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	707
28331 2874db5462d3 templater: fix get() to evaluate arguments eagerly Yuya Nishihara <yuya@tcha.org> parents: 28225 diff changeset	708 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	709 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	710 # 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	711 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	712
28331 2874db5462d3 templater: fix get() to evaluate arguments eagerly Yuya Nishihara <yuya@tcha.org> parents: 28225 diff changeset	713 key = evalfuncarg(context, mapping, args[1])
27892 83aef8d5bc1b templater: make get(dict, key) return a single value Yuya Nishihara <yuya@tcha.org> parents: 27891 diff changeset	714 return dictarg.get(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	715
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	716 @templatefunc('if(expr, then[, else])')
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	717 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	718 """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	719 an expression."""
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	720 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	721 # i18n: "if" is a keyword
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	722 raise error.ParseError(_("if expects two or three arguments"))
ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	723
29827 034412ca28c3 templater: fix if() to not evaluate False as bool('False') Yuya Nishihara <yuya@tcha.org> parents: 29826 diff changeset	724 test = evalboolean(context, mapping, args[0])
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	725 if test:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	726 yield evalrawexp(context, mapping, args[1])
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	727 elif len(args) == 3:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	728 yield evalrawexp(context, mapping, args[2])
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	729
30049 f18cc848b48e templater: use "needle" and "haystack" as (meta-)variables for ifcontains() Anton Shestakov <av6@dwimlabs.net> parents: 30012 diff changeset	730 @templatefunc('ifcontains(needle, haystack, then[, else])')
20518 1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	731 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	732 """Conditionally execute based
30049 f18cc848b48e templater: use "needle" and "haystack" as (meta-)variables for ifcontains() Anton Shestakov <av6@dwimlabs.net> parents: 30012 diff changeset	733 on whether the item "needle" is in "haystack"."""
20518 1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	734 if not (3 <= len(args) <= 4):
1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	735 # i18n: "ifcontains" is a keyword
1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	736 raise error.ParseError(_("ifcontains expects three or four arguments"))
1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	737
30049 f18cc848b48e templater: use "needle" and "haystack" as (meta-)variables for ifcontains() Anton Shestakov <av6@dwimlabs.net> parents: 30012 diff changeset	738 needle = evalstring(context, mapping, args[0])
f18cc848b48e templater: use "needle" and "haystack" as (meta-)variables for ifcontains() Anton Shestakov <av6@dwimlabs.net> parents: 30012 diff changeset	739 haystack = evalfuncarg(context, mapping, args[1])
20518 1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	740
30049 f18cc848b48e templater: use "needle" and "haystack" as (meta-)variables for ifcontains() Anton Shestakov <av6@dwimlabs.net> parents: 30012 diff changeset	741 if needle in haystack:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	742 yield evalrawexp(context, mapping, args[2])
20518 1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	743 elif len(args) == 4:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	744 yield evalrawexp(context, mapping, args[3])
20518 1e43f15a647f template: add ifcontains template function Durham Goode <durham@fb.com> parents: 20371 diff changeset	745
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	746 @templatefunc('ifeq(expr1, expr2, then[, else])')
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	747 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	748 """Conditionally execute based on
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	749 whether 2 items are equivalent."""
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	750 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	751 # i18n: "ifeq" is a keyword
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	752 raise error.ParseError(_("ifeq expects three or four arguments"))
ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	753
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	754 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	755 match = evalstring(context, mapping, args[1])
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	756 if test == match:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	757 yield evalrawexp(context, mapping, args[2])
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	758 elif len(args) == 4:
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	759 yield evalrawexp(context, mapping, args[3])
17636 ce18dbcd91c8 templater: add if/ifeq conditionals Matt Mackall <mpm@selenic.com> parents: 17635 diff changeset	760
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	761 @templatefunc('join(list, sep)')
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	762 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	763 """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	764 if not (1 <= len(args) <= 2):
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	765 # i18n: "join" is a keyword
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	766 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	767
34333 e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	768 # TODO: perhaps this should be evalfuncarg(), but it can't because hgweb
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	769 # abuses generator as a keyword that returns a list of dicts.
e60c601953d7 templater: extract helper to just evaluate template expression Yuya Nishihara <yuya@tcha.org> parents: 34332 diff changeset	770 joinset = evalrawexp(context, mapping, args[0])
34335 dd28b1f55eb8 templatekw: just pass underlying value (or key) to joinfmt() function Yuya Nishihara <yuya@tcha.org> parents: 34333 diff changeset	771 joinfmt = getattr(joinset, 'joinfmt', pycompat.identity)
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	772 joiner = " "
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	773 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	774 joiner = evalstring(context, mapping, args[1])
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	775
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	776 first = True
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	777 for x in joinset:
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	778 if first:
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	779 first = False
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	780 else:
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	781 yield joiner
34335 dd28b1f55eb8 templatekw: just pass underlying value (or key) to joinfmt() function Yuya Nishihara <yuya@tcha.org> parents: 34333 diff changeset	782 yield joinfmt(x)
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	783
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	784 @templatefunc('label(label, expr)')
18289 9bfb53106328 templater: add no-op template function 'label' Sean Farley <sean.michael.farley@gmail.com> parents: 17991 diff changeset	785 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	786 """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	787 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	788 automatic colorization."""
18289 9bfb53106328 templater: add no-op template function 'label' Sean Farley <sean.michael.farley@gmail.com> parents: 17991 diff changeset	789 if len(args) != 2:
9bfb53106328 templater: add no-op template function 'label' Sean Farley <sean.michael.farley@gmail.com> parents: 17991 diff changeset	790 # i18n: "label" is a keyword
9bfb53106328 templater: add no-op template function 'label' Sean Farley <sean.michael.farley@gmail.com> parents: 17991 diff changeset	791 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	792
28462 dbba18ba26d4 templater: make label() just fail if ui object isn't available Yuya Nishihara <yuya@tcha.org> parents: 28403 diff changeset	793 ui = mapping['ui']
28374 af3bd9d1dbc1 templater: move label() function from color extension Yuya Nishihara <yuya@tcha.org> parents: 28373 diff changeset	794 thing = evalstring(context, mapping, args[1])
af3bd9d1dbc1 templater: move label() function from color extension Yuya Nishihara <yuya@tcha.org> parents: 28373 diff changeset	795 # 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	796 # etc. don't need to be quoted
af3bd9d1dbc1 templater: move label() function from color extension Yuya Nishihara <yuya@tcha.org> parents: 28373 diff changeset	797 label = evalstringliteral(context, mapping, args[0])
af3bd9d1dbc1 templater: move label() function from color extension Yuya Nishihara <yuya@tcha.org> parents: 28373 diff changeset	798
28384 3356bf61fa25 formatter: make labels work with templated output Kostia Balytskyi <ikostia@fb.com> parents: 28374 diff changeset	799 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	800
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	801 @templatefunc('latesttag([pattern])')
26485 43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	802 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	803 """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	804 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	805 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	806 the string "null"."""
26485 43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	807 if len(args) > 1:
43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	808 # 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	809 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	810
43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	811 pattern = None
43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	812 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	813 pattern = evalstring(context, mapping, args[0])
26485 43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	814
43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	815 return templatekw.showlatesttags(pattern, **mapping)
43bf9471fae9 templater: introduce {latesttag()} function to match a pattern (issue4184) Matt Harbison <matt_harbison@yahoo.com> parents: 26334 diff changeset	816
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	817 @templatefunc('localdate(date[, tz])')
26127 7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	818 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	819 """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	820 The default is local date."""
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	821 if not (1 <= len(args) <= 2):
26127 7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	822 # i18n: "localdate" is a keyword
26128 51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	823 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	824
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	825 date = evalfuncarg(context, mapping, args[0])
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	826 try:
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	827 date = util.parsedate(date)
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	828 except AttributeError: # not str nor date tuple
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	829 # i18n: "localdate" is a keyword
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	830 raise error.ParseError(_("localdate expects a date information"))
26128 51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	831 if len(args) >= 2:
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	832 tzoffset = None
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	833 tz = evalfuncarg(context, mapping, args[1])
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	834 if isinstance(tz, str):
29636 84ef4517de03 date: refactor timezone parsing Matt Mackall <mpm@selenic.com> parents: 29085 diff changeset	835 tzoffset, remainder = util.parsetimezone(tz)
84ef4517de03 date: refactor timezone parsing Matt Mackall <mpm@selenic.com> parents: 29085 diff changeset	836 if remainder:
84ef4517de03 date: refactor timezone parsing Matt Mackall <mpm@selenic.com> parents: 29085 diff changeset	837 tzoffset = None
26128 51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	838 if tzoffset is None:
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	839 try:
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	840 tzoffset = int(tz)
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	841 except (TypeError, ValueError):
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	842 # i18n: "localdate" is a keyword
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	843 raise error.ParseError(_("localdate expects a timezone"))
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	844 else:
51f6940d3b4f templater: add optional timezone argument to localdate() Yuya Nishihara <yuya@tcha.org> parents: 26127 diff changeset	845 tzoffset = util.makedate()[1]
26127 7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	846 return (date[0], tzoffset)
7012be5ab5bd templater: port localdate filter to a function Yuya Nishihara <yuya@tcha.org> parents: 26125 diff changeset	847
34013 c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	848 @templatefunc('max(iterable)')
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	849 def max_(context, mapping, args, **kwargs):
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	850 """Return the max of an iterable"""
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	851 if len(args) != 1:
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	852 # i18n: "max" is a keyword
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	853 raise error.ParseError(_("max expects one arguments"))
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	854
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	855 iterable = evalfuncarg(context, mapping, args[0])
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	856 try:
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	857 return max(iterable)
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	858 except (TypeError, ValueError):
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	859 # i18n: "max" is a keyword
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	860 raise error.ParseError(_("max first argument should be an iterable"))
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	861
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	862 @templatefunc('min(iterable)')
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	863 def min_(context, mapping, args, **kwargs):
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	864 """Return the min of an iterable"""
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	865 if len(args) != 1:
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	866 # i18n: "min" is a keyword
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	867 raise error.ParseError(_("min expects one arguments"))
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	868
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	869 iterable = evalfuncarg(context, mapping, args[0])
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	870 try:
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	871 return min(iterable)
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	872 except (TypeError, ValueError):
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	873 # i18n: "min" is a keyword
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	874 raise error.ParseError(_("min first argument should be an iterable"))
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	875
30115 8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	876 @templatefunc('mod(a, b)')
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	877 def mod(context, mapping, args):
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	878 """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	879 if not len(args) == 2:
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	880 # i18n: "mod" is a keyword
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	881 raise error.ParseError(_("mod expects two arguments"))
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	882
30116 1c01fa29630f templater: handle division by zero in arithmetic Simon Farnsworth <simonfar@fb.com> parents: 30115 diff changeset	883 func = lambda a, b: a % b
1c01fa29630f templater: handle division by zero in arithmetic Simon Farnsworth <simonfar@fb.com> parents: 30115 diff changeset	884 return runarithmetic(context, mapping, (func, args[0], args[1]))
30115 8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	885
34294 7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	886 @templatefunc('obsfateoperations(markers)')
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	887 def obsfateoperations(context, mapping, args):
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	888 """Compute obsfate related information based on markers (EXPERIMENTAL)"""
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	889 if len(args) != 1:
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	890 # i18n: "obsfateoperations" is a keyword
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	891 raise error.ParseError(_("obsfateoperations expects one arguments"))
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	892
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	893 markers = evalfuncarg(context, mapping, args[0])
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	894
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	895 try:
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	896 data = obsutil.markersoperations(markers)
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	897 return templatekw.hybridlist(data, name='operation')
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	898 except (TypeError, KeyError):
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	899 # i18n: "obsfateoperations" is a keyword
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	900 errmsg = _("obsfateoperations first argument should be an iterable")
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	901 raise error.ParseError(errmsg)
7cdc8c5a481a templates: introduce a obsfateoperation() function Martin von Zweigbergk <martinvonz@google.com> parents: 34257 diff changeset	902
34013 c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	903 @templatefunc('obsfatedate(markers)')
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	904 def obsfatedate(context, mapping, args):
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	905 """Compute obsfate related information based on markers (EXPERIMENTAL)"""
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	906 if len(args) != 1:
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	907 # i18n: "obsfatedate" is a keyword
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	908 raise error.ParseError(_("obsfatedate expects one arguments"))
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	909
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	910 markers = evalfuncarg(context, mapping, args[0])
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	911
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	912 try:
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	913 data = obsutil.markersdates(markers)
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	914 return templatekw.hybridlist(data, name='date', fmt='%d %d')
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	915 except (TypeError, KeyError):
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	916 # i18n: "obsfatedate" is a keyword
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	917 errmsg = _("obsfatedate first argument should be an iterable")
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	918 raise error.ParseError(errmsg)
c35c0f54f420 template: compute dates in obsfatedate Boris Feld <boris.feld@octobus.net> parents: 34012 diff changeset	919
34012 38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	920 @templatefunc('obsfateusers(markers)')
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	921 def obsfateusers(context, mapping, args):
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	922 """Compute obsfate related information based on markers (EXPERIMENTAL)"""
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	923 if len(args) != 1:
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	924 # i18n: "obsfateusers" is a keyword
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	925 raise error.ParseError(_("obsfateusers expects one arguments"))
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	926
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	927 markers = evalfuncarg(context, mapping, args[0])
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	928
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	929 try:
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	930 data = obsutil.markersusers(markers)
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	931 return templatekw.hybridlist(data, name='user')
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	932 except (TypeError, KeyError, ValueError):
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	933 # i18n: "obsfateusers" is a keyword
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	934 msg = _("obsfateusers first argument should be an iterable of "
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	935 "obsmakers")
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	936 raise error.ParseError(msg)
38f08eaba6b0 template: compute user in obsfateusers Boris Feld <boris.feld@octobus.net> parents: 34011 diff changeset	937
34011 3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	938 @templatefunc('obsfateverb(successors)')
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	939 def obsfateverb(context, mapping, args):
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	940 """Compute obsfate related information based on successors (EXPERIMENTAL)"""
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	941 if len(args) != 1:
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	942 # i18n: "obsfateverb" is a keyword
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	943 raise error.ParseError(_("obsfateverb expects one arguments"))
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	944
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	945 successors = evalfuncarg(context, mapping, args[0])
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	946
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	947 try:
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	948 return obsutil.successorsetverb(successors)
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	949 except TypeError:
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	950 # i18n: "obsfateverb" is a keyword
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	951 errmsg = _("obsfateverb first argument should be countable")
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	952 raise error.ParseError(errmsg)
3d0f8918351b template: compute verb in obsfateverb Boris Feld <boris.feld@octobus.net> parents: 33554 diff changeset	953
30083 bd1f043d1ea3 templater: add relpath() to convert repo path to relative path (issue5394) Yuya Nishihara <yuya@tcha.org> parents: 30049 diff changeset	954 @templatefunc('relpath(path)')
bd1f043d1ea3 templater: add relpath() to convert repo path to relative path (issue5394) Yuya Nishihara <yuya@tcha.org> parents: 30049 diff changeset	955 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	956 """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	957 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	958 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	959 # 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	960 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	961
bd1f043d1ea3 templater: add relpath() to convert repo path to relative path (issue5394) Yuya Nishihara <yuya@tcha.org> parents: 30049 diff changeset	962 repo = mapping['ctx'].repo()
bd1f043d1ea3 templater: add relpath() to convert repo path to relative path (issue5394) Yuya Nishihara <yuya@tcha.org> parents: 30049 diff changeset	963 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	964 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	965
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	966 @templatefunc('revset(query[, formatargs...])')
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	967 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	968 """Execute a revision set query. See
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	969 :hg:`help revset`."""
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	970 if not len(args) > 0:
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	971 # i18n: "revset" is a keyword
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	972 raise error.ParseError(_("revset expects one or more arguments"))
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	973
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	974 raw = evalstring(context, mapping, args[0])
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	975 ctx = mapping['ctx']
24337 696ab1a24ae0 templater: replace 'ctx._repo' with 'ctx.repo()' Matt Harbison <matt_harbison@yahoo.com> parents: 24306 diff changeset	976 repo = ctx.repo()
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	977
22304 5678b0e3608f templater: enable alias predicates to be used in "revset()" function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21960 diff changeset	978 def query(expr):
33554 2943141f5e07 revset: pass repo when passing ui Gregory Szorc <gregory.szorc@gmail.com> parents: 33033 diff changeset	979 m = revsetmod.match(repo.ui, expr, repo=repo)
24114 fafd9a1284cf revset: make match function initiate query from full set by default Yuya Nishihara <yuya@tcha.org> parents: 23167 diff changeset	980 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	981
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	982 if len(args) > 1:
28333 41373244f4e5 templater: fix revset() to evaluate format arguments eagerly Yuya Nishihara <yuya@tcha.org> parents: 28332 diff changeset	983 formatargs = [evalfuncarg(context, mapping, a) for a in args[1:]]
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 30630 diff changeset	984 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	985 revs = list(revs)
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	986 else:
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	987 revsetcache = mapping['cache'].setdefault("revsetcache", {})
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	988 if raw in revsetcache:
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	989 revs = revsetcache[raw]
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	990 else:
22304 5678b0e3608f templater: enable alias predicates to be used in "revset()" function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 21960 diff changeset	991 revs = query(raw)
28178 96f2d50fb9f6 templater: factor out type conversion of revset() result Yuya Nishihara <yuya@tcha.org> parents: 27940 diff changeset	992 revs = list(revs)
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	993 revsetcache[raw] = revs
cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	994
26234 e4609ec959f8 templater: switch ctx of list expression to rev of revset() (BC) Yuya Nishihara <yuya@tcha.org> parents: 26231 diff changeset	995 return templatekw.showrevslist("revision", revs, **mapping)
20519 cda9d2b6beab template: add revset() template function Durham Goode <durham@fb.com> parents: 20518 diff changeset	996
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	997 @templatefunc('rstdoc(text, style)')
18747 f5db3092790f hgweb: generate HTML documentation Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18582 diff changeset	998 def rstdoc(context, mapping, args):
30342 318a24b52eeb spelling: fixes of non-dictionary words Mads Kiilerich <madski@unity3d.com> parents: 30232 diff changeset	999 """Format reStructuredText."""
18747 f5db3092790f hgweb: generate HTML documentation Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18582 diff changeset	1000 if len(args) != 2:
f5db3092790f hgweb: generate HTML documentation Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18582 diff changeset	1001 # i18n: "rstdoc" is a keyword
f5db3092790f hgweb: generate HTML documentation Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18582 diff changeset	1002 raise error.ParseError(_("rstdoc expects two arguments"))
f5db3092790f hgweb: generate HTML documentation Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18582 diff changeset	1003
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	1004 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	1005 style = evalstring(context, mapping, args[1])
18747 f5db3092790f hgweb: generate HTML documentation Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 18582 diff changeset	1006
19079 1e433b5457fd hgweb: make help verbose again (issue3899) Alexander Plavin <me@aplavin.ru> parents: 19058 diff changeset	1007 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	1008
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	1009 @templatefunc('separate(sep, args)', argspec='sep *args')
29085 df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1010 def separate(context, mapping, args):
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1011 """Add a separator between non-empty arguments."""
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	1012 if 'sep' not in args:
29085 df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1013 # i18n: "separate" is a keyword
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1014 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	1015
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	1016 sep = evalstring(context, mapping, args['sep'])
29085 df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1017 first = True
31886 bdda942f4b9c templater: add support for keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 31885 diff changeset	1018 for arg in args['args']:
29085 df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1019 argstr = evalstring(context, mapping, arg)
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1020 if not argstr:
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1021 continue
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1022 if first:
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1023 first = False
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1024 else:
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1025 yield sep
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1026 yield argstr
df838803c1d4 templater: add separate() template function Martin von Zweigbergk <martinvonz@google.com> parents: 28957 diff changeset	1027
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	1028 @templatefunc('shortest(node, minlength=4)')
20369 9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1029 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	1030 """Obtain the shortest representation of
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	1031 a node."""
20369 9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1032 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	1033 # i18n: "shortest" is a keyword
20369 9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1034 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	1035
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	1036 node = evalstring(context, mapping, args[0])
20369 9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1037
9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1038 minlength = 4
9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1039 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	1040 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	1041 # 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	1042 _("shortest() expects an integer minlength"))
20369 9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1043
30232 362740e05460 templater: use unfiltered changelog to calculate shortest() at constant time Yuya Nishihara <yuya@tcha.org> parents: 30231 diff changeset	1044 # _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	1045 # 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	1046 # unfiltered space, which means some hashes may be slightly longer.
362740e05460 templater: use unfiltered changelog to calculate shortest() at constant time Yuya Nishihara <yuya@tcha.org> parents: 30231 diff changeset	1047 cl = mapping['ctx']._repo.unfiltered().changelog
34257 448725a2ef73 templater: extract shortest() logic from template function Martin von Zweigbergk <martinvonz@google.com> parents: 34154 diff changeset	1048 return cl.shortest(node, minlength)
20369 9c6b86dd2ed2 template: add shortest(node) template function Durham Goode <durham@fb.com> parents: 20312 diff changeset	1049
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	1050 @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	1051 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	1052 """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	1053 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	1054 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	1055 # 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	1056 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	1057
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	1058 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	1059 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	1060 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	1061 return text.strip(chars)
867b9957d895 templater: add strip function with chars as an extra argument Alexander Plavin <me@aplavin.ru> parents: 19228 diff changeset	1062 return text.strip()
867b9957d895 templater: add strip function with chars as an extra argument Alexander Plavin <me@aplavin.ru> parents: 19228 diff changeset	1063
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	1064 @templatefunc('sub(pattern, replacement, expression)')
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	1065 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	1066 """Perform text substitution
24586 90e3f5d22dad templater: add consistent docstrings to functions Gregory Szorc <gregory.szorc@gmail.com> parents: 24337 diff changeset	1067 using regular expressions."""
19390 3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	1068 if len(args) != 3:
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	1069 # i18n: "sub" is a keyword
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	1070 raise error.ParseError(_("sub expects three arguments"))
3af3a165db18 templater: sort functions alphabetically, as filters are Alexander Plavin <me@aplavin.ru> parents: 19330 diff changeset	1071
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	1072 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	1073 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	1074 src = evalstring(context, mapping, args[2])
26188 662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1075 try:
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1076 patre = re.compile(pat)
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1077 except re.error:
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1078 # i18n: "sub" is a keyword
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1079 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	1080 try:
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1081 yield patre.sub(rpl, src)
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1082 except re.error:
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1083 # i18n: "sub" is a keyword
662ea52d5dca templater: catch regexp error at sub() function Yuya Nishihara <yuya@tcha.org> parents: 26128 diff changeset	1084 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	1085
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	1086 @templatefunc('startswith(pattern, text)')
21821 4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1087 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	1088 """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	1089 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	1090 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	1091 # i18n: "startswith" is a keyword
21821 4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1092 raise error.ParseError(_("startswith expects two arguments"))
4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1093
28348 ccedb17a5657 templater: factor out thin helper that evaluates argument as string Yuya Nishihara <yuya@tcha.org> parents: 28346 diff changeset	1094 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	1095 text = evalstring(context, mapping, args[1])
21821 4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1096 if text.startswith(patn):
4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1097 return text
4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1098 return ''
4a445dc5abff templater: introduce startswith function Ryan McElroy <rmcelroy@fb.com> parents: 21798 diff changeset	1099
28696 efa192203623 templater: use templatefunc to mark a function as template function FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28695 diff changeset	1100 @templatefunc('word(number, text[, separator])')
21846 8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1101 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	1102 """Return the nth word from a string."""
21846 8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1103 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	1104 # i18n: "word" is a keyword
21846 8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1105 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	1106 % len(args))
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1107
28343 a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	1108 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	1109 # i18n: "word" is a keyword
a6c2310b3827 templater: factor out function that evaluates argument as integer Yuya Nishihara <yuya@tcha.org> parents: 28334 diff changeset	1110 _("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	1111 text = evalstring(context, mapping, args[1])
21846 8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1112 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	1113 splitter = evalstring(context, mapping, args[2])
21846 8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1114 else:
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1115 splitter = None
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1116
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1117 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	1118 if num >= len(tokens) or num < -len(tokens):
21846 8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1119 return ''
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1120 else:
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1121 return tokens[num]
8f23f8096606 templater: introduce word function Ryan McElroy <rmcelroy@fb.com> parents: 21822 diff changeset	1122
25001 9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	1123 # methods to interpret function arguments or inner expressions (e.g. {_(x)})
9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	1124 exprmethods = {
25002 829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	1125 "integer": lambda e, c: (runinteger, e[1]),
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1126 "string": lambda e, c: (runstring, e[1]),
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1127 "symbol": lambda e, c: (runsymbol, e[1]),
25596 c1975809a6b5 templater: take any string literals as template, but not for rawstring (BC) Yuya Nishihara <yuya@tcha.org> parents: 25595 diff changeset	1128 "template": buildtemplate,
25001 9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	1129 "group": lambda e, c: compileexp(e[1], c, exprmethods),
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1130 # ".": buildmember,
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1131 "\|": buildfilter,
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1132 "%": buildmap,
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1133 "func": buildfunc,
31885 d18b624c1c06 templater: add parsing rule for key-value pair Yuya Nishihara <yuya@tcha.org> parents: 31884 diff changeset	1134 "keyvalue": buildkeyvaluepair,
30115 8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	1135 "+": lambda e, c: buildarithmetic(e, c, lambda a, b: a + b),
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	1136 "-": lambda e, c: buildarithmetic(e, c, lambda a, b: a - b),
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	1137 "negate": buildnegate,
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	1138 "": lambda e, c: buildarithmetic(e, c, lambda a, b: a b),
8e42dfde93d1 templater: provide arithmetic operations on integers Simon Farnsworth <simonfar@fb.com> parents: 30083 diff changeset	1139 "/": lambda e, c: buildarithmetic(e, c, lambda a, b: a // b),
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1140 }
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1141
25001 9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	1142 # methods to interpret top-level template (e.g. {x}, {x\|_}, {x % "y"})
9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	1143 methods = exprmethods.copy()
25002 829faf8ab605 templater: tokenize decimal integer literal (issue4638) (BC) Yuya Nishihara <yuya@tcha.org> parents: 25001 diff changeset	1144 methods["integer"] = exprmethods["symbol"] # '{1}' as variable
25001 9668c1a433b3 templater: switch methods table on compileexp() of func args and inner expr Yuya Nishihara <yuya@tcha.org> parents: 24988 diff changeset	1145
28912 867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1146 class _aliasrules(parser.basealiasrules):
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1147 """Parsing and expansion rule set of template aliases"""
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1148 _section = _('template alias')
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1149 _parse = staticmethod(_parseexpr)
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1150
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1151 @staticmethod
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1152 def _trygetfunc(tree):
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1153 """Return (name, args) if tree is func(...) or ...\|filter; otherwise
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1154 None"""
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1155 if tree[0] == 'func' and tree[1][0] == 'symbol':
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1156 return tree[1][1], getlist(tree[2])
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1157 if tree[0] == '\|' and tree[2][0] == 'symbol':
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1158 return tree[2][1], [tree[1]]
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1159
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1160 def expandaliases(tree, aliases):
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1161 """Return new tree of aliases are expanded"""
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1162 aliasmap = _aliasrules.buildmap(aliases)
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1163 return _aliasrules.expand(aliasmap, tree)
867d6ba2353d templater: add parsing and expansion rules to process "templatealias" section Yuya Nishihara <yuya@tcha.org> parents: 28911 diff changeset	1164
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1165 # template engine
1901 c64bef3d7043 use safer string parser for template engine. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1900 diff changeset	1166
8360 acc202b71619 templater: provide the standard template filters by default Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8312 diff changeset	1167 stringify = templatefilters.stringify
7107 125c8fedcbe0 Allow hgweb to search for templates in more than one path. Brendan Cully <brendan@kublai.com> parents: 6783 diff changeset	1168
10850 a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1169 def _flatten(thing):
a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1170 '''yield a single stream from a possibly nested set of iterators'''
31880 a0f2d83f8083 templater: remove __iter__() from _hybrid, resolve it explicitly Yuya Nishihara <yuya@tcha.org> parents: 31850 diff changeset	1171 thing = templatekw.unwraphybrid(thing)
32988 11c0bb4ccc76 py3: replace str with bytes in isinstance() Pulkit Goyal <7895pulkit@gmail.com> parents: 32891 diff changeset	1172 if isinstance(thing, bytes):
10850 a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1173 yield thing
29826 0d5cc0c18b4e templater: make it clearer that _flatten() omits None Yuya Nishihara <yuya@tcha.org> parents: 29823 diff changeset	1174 elif thing is None:
0d5cc0c18b4e templater: make it clearer that _flatten() omits None Yuya Nishihara <yuya@tcha.org> parents: 29823 diff changeset	1175 pass
14944 e2c413bde8a5 globally: use safehasattr(x, '__iter__') instead of hasattr(x, '__iter__') Augie Fackler <durin42@gmail.com> parents: 14943 diff changeset	1176 elif not util.safehasattr(thing, '__iter__'):
32992 8779d35c168d py3: use pycompat.bytestr() in place of str() Pulkit Goyal <7895pulkit@gmail.com> parents: 32988 diff changeset	1177 yield pycompat.bytestr(thing)
10852 0d50586a9d31 templater: raise nested functions Matt Mackall <mpm@selenic.com> parents: 10850 diff changeset	1178 else:
10850 a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1179 for i in thing:
31880 a0f2d83f8083 templater: remove __iter__() from _hybrid, resolve it explicitly Yuya Nishihara <yuya@tcha.org> parents: 31850 diff changeset	1180 i = templatekw.unwraphybrid(i)
32988 11c0bb4ccc76 py3: replace str with bytes in isinstance() Pulkit Goyal <7895pulkit@gmail.com> parents: 32891 diff changeset	1181 if isinstance(i, bytes):
10850 a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1182 yield i
29826 0d5cc0c18b4e templater: make it clearer that _flatten() omits None Yuya Nishihara <yuya@tcha.org> parents: 29823 diff changeset	1183 elif i is None:
0d5cc0c18b4e templater: make it clearer that _flatten() omits None Yuya Nishihara <yuya@tcha.org> parents: 29823 diff changeset	1184 pass
14944 e2c413bde8a5 globally: use safehasattr(x, '__iter__') instead of hasattr(x, '__iter__') Augie Fackler <durin42@gmail.com> parents: 14943 diff changeset	1185 elif not util.safehasattr(i, '__iter__'):
32992 8779d35c168d py3: use pycompat.bytestr() in place of str() Pulkit Goyal <7895pulkit@gmail.com> parents: 32988 diff changeset	1186 yield pycompat.bytestr(i)
29826 0d5cc0c18b4e templater: make it clearer that _flatten() omits None Yuya Nishihara <yuya@tcha.org> parents: 29823 diff changeset	1187 else:
10850 a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1188 for j in _flatten(i):
a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1189 yield j
a63391e26284 templater: use recursive flattening Matt Mackall <mpm@selenic.com> parents: 10849 diff changeset	1190
24988 e8ff0b09acac templater: rename parsestring() to unquotestring() (API) Yuya Nishihara <yuya@tcha.org> parents: 24987 diff changeset	1191 def unquotestring(s):
28630 bf35644b9f3a templater: relax unquotestring() to fall back to bare string Yuya Nishihara <yuya@tcha.org> parents: 28628 diff changeset	1192 '''unwrap quotes if any; otherwise returns unmodified string'''
28687 29c249dfb4ef templater: do not strip non-quote characters from template config Yuya Nishihara <yuya@tcha.org> parents: 28630 diff changeset	1193 if len(s) < 2 or s[0] not in "'\"" or s[0] != s[-1]:
28630 bf35644b9f3a templater: relax unquotestring() to fall back to bare string Yuya Nishihara <yuya@tcha.org> parents: 28628 diff changeset	1194 return s
25696 c1cac25ad1a6 templater: remove workaround for escaped quoted string in quoted template Yuya Nishihara <yuya@tcha.org> parents: 25695 diff changeset	1195 return s[1:-1]
1896 f8f818a04f5b move hgweb template code out to templater Vadim Gelfer <vadim.gelfer@gmail.com> parents: diff changeset	1196
8218 e61cb2813d2a templater: separate template management and actual string processing Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8198 diff changeset	1197 class engine(object):
1909 37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1198 '''template expansion engine.
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1199
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1200 template expansion works like this. a map file contains key=value
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1201 pairs. if value is quoted, it is treated as string. otherwise, it
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1202 is treated as name of template file.
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1203
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1204 templater is asked to expand a key in map. it looks up key, and
4334 66a3fe30f9fc minor typo fix in templater's docstring TK Soh <teekaysoh@yahoo.com> parents: 3904 diff changeset	1205 looks for strings like this: {foo}. it expands {foo} by looking up
1909 37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1206 foo in map, and substituting it. expansion is recursive: it stops
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1207 when there is no more {foo} to replace.
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1208
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1209 expansion also allows formatting and filtering.
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1210
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1211 format uses key to expand each item in list. syntax is
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1212 {key%format}.
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1213
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1214 filter uses function to transform value. syntax is
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1215 {key\|filter1\|filter2\|...}.'''
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1216
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1217 def __init__(self, loader, filters=None, defaults=None, aliases=()):
10848 01346cea5485 templater: privatize class variables Matt Mackall <mpm@selenic.com> parents: 10847 diff changeset	1218 self._loader = loader
26330 ec4f3755d997 templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26234 diff changeset	1219 if filters is None:
ec4f3755d997 templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26234 diff changeset	1220 filters = {}
10848 01346cea5485 templater: privatize class variables Matt Mackall <mpm@selenic.com> parents: 10847 diff changeset	1221 self._filters = filters
26331 2c6a741bf05e templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26330 diff changeset	1222 if defaults is None:
2c6a741bf05e templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26330 diff changeset	1223 defaults = {}
10848 01346cea5485 templater: privatize class variables Matt Mackall <mpm@selenic.com> parents: 10847 diff changeset	1224 self._defaults = defaults
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1225 self._aliasmap = _aliasrules.buildmap(aliases)
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	1226 self._cache = {} # key: (func, data)
8218 e61cb2813d2a templater: separate template management and actual string processing Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8198 diff changeset	1227
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1228 def _load(self, t):
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1229 '''load, parse, and cache a template'''
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1230 if t not in self._cache:
27940 cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	1231 # put poison to cut recursion while compiling 't'
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	1232 self._cache[t] = (_runrecursivesymbol, t)
27940 cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	1233 try:
28956 eea98190ed73 templater: inline compiletemplate() function into engine Yuya Nishihara <yuya@tcha.org> parents: 28954 diff changeset	1234 x = parse(self._loader(t))
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1235 if self._aliasmap:
d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1236 x = _aliasrules.expand(self._aliasmap, x)
28956 eea98190ed73 templater: inline compiletemplate() function into engine Yuya Nishihara <yuya@tcha.org> parents: 28954 diff changeset	1237 self._cache[t] = compileexp(x, self, methods)
27940 cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	1238 except: # re-raises
cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	1239 del self._cache[t]
cfe7da66f555 templater: abort if infinite recursion detected while compiling Yuya Nishihara <yuya@tcha.org> parents: 27939 diff changeset	1240 raise
13176 895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1241 return self._cache[t]
895f54a79c6e templater: use the parser.py parser to extend the templater syntax Matt Mackall <mpm@selenic.com> parents: 13175 diff changeset	1242
10853 b6f6d9fd53d6 templater: drop raw method Matt Mackall <mpm@selenic.com> parents: 10852 diff changeset	1243 def process(self, t, mapping):
b6f6d9fd53d6 templater: drop raw method Matt Mackall <mpm@selenic.com> parents: 10852 diff changeset	1244 '''Perform expansion. t is name of map element to expand.
b6f6d9fd53d6 templater: drop raw method Matt Mackall <mpm@selenic.com> parents: 10852 diff changeset	1245 mapping contains added elements for use during expansion. Is a
b6f6d9fd53d6 templater: drop raw method Matt Mackall <mpm@selenic.com> parents: 10852 diff changeset	1246 generator.'''
28545 1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	1247 func, data = self._load(t)
1d461ee26e1b templater: lift parsed and compiled templates to generic data types Yuya Nishihara <yuya@tcha.org> parents: 28462 diff changeset	1248 return _flatten(func(self, mapping, data))
8218 e61cb2813d2a templater: separate template management and actual string processing Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8198 diff changeset	1249
8361 d8c5a7f25a40 templater: make the templating engine pluggable to some extent Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8360 diff changeset	1250 engines = {'default': engine}
d8c5a7f25a40 templater: make the templating engine pluggable to some extent Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8360 diff changeset	1251
19125 6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1252 def stylelist():
22634 e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1253 paths = templatepaths()
20312 268a5ab5c27b templater: selecting a style with no templates does not crash (issue4140) Simon Heimberg <simohe@besonet.ch> parents: 20067 diff changeset	1254 if not paths:
268a5ab5c27b templater: selecting a style with no templates does not crash (issue4140) Simon Heimberg <simohe@besonet.ch> parents: 20067 diff changeset	1255 return _('no templates found, try `hg debuginstall` for more info')
27637 b502138f5faa cleanup: remove superfluous space after space after equals (python) timeless <timeless@mozdev.org> parents: 27293 diff changeset	1256 dirlist = os.listdir(paths[0])
19125 6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1257 stylelist = []
6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1258 for file in dirlist:
6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1259 split = file.split(".")
28403 d2e154dddb6e templater: ignore orig/rej files timeless <timeless@mozdev.org> parents: 28384 diff changeset	1260 if split[-1] in ('orig', 'rej'):
d2e154dddb6e templater: ignore orig/rej files timeless <timeless@mozdev.org> parents: 28384 diff changeset	1261 continue
19125 6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1262 if split[0] == "map-cmdline":
6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1263 stylelist.append(split[1])
19127 d982edcfe7f0 templater: fix output instability from gsoc patches Augie Fackler <raf@durin42.com> parents: 19125 diff changeset	1264 return ", ".join(sorted(stylelist))
19125 6ba6e345961e templater: show the style list when I try to use a wrong one Iulian Stana <julian.stana@gmail.com> parents: 19079 diff changeset	1265
28953 7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1266 def _readmapfile(mapfile):
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1267 """Load template elements from the given map file"""
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1268 if not os.path.exists(mapfile):
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1269 raise error.Abort(_("style '%s' not found") % mapfile,
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1270 hint=_("available styles: %s") % stylelist())
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1271
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1272 base = os.path.dirname(mapfile)
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1273 conf = config.config(includepaths=templatepaths())
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1274 conf.read(mapfile)
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1275
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1276 cache = {}
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1277 tmap = {}
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1278 for key, val in conf[''].items():
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1279 if not val:
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1280 raise error.ParseError(_('missing value'), conf.source('', key))
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1281 if val[0] in "'\"":
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1282 if val[0] != val[-1]:
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1283 raise error.ParseError(_('unmatched quotes'),
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1284 conf.source('', key))
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1285 cache[key] = unquotestring(val)
29823 01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1286 elif key == "__base__":
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1287 # treat as a pointer to a base class for this style
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1288 path = util.normpath(os.path.join(base, val))
29858 b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1289
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1290 # fallback check in template paths
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1291 if not os.path.exists(path):
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1292 for p in templatepaths():
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1293 p2 = util.normpath(os.path.join(p, val))
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1294 if os.path.isfile(p2):
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1295 path = p2
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1296 break
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1297 p3 = util.normpath(os.path.join(p2, "map"))
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1298 if os.path.isfile(p3):
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1299 path = p3
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1300 break
b1f69dbdd76b templater: add template path to __base__ search Matt Mackall <mpm@selenic.com> parents: 29829 diff changeset	1301
29823 01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1302 bcache, btmap = _readmapfile(path)
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1303 for k in bcache:
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1304 if k not in cache:
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1305 cache[k] = bcache[k]
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1306 for k in btmap:
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1307 if k not in tmap:
01f036f0e40b templater: add inheritance support to style maps Matt Mackall <mpm@selenic.com> parents: 29636 diff changeset	1308 tmap[k] = btmap[k]
28953 7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1309 else:
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1310 val = 'default', val
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1311 if ':' in val[1]:
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1312 val = val[1].split(':', 1)
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1313 tmap[key] = val[0], os.path.join(base, val[1])
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1314 return cache, tmap
7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1315
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26564 diff changeset	1316 class TemplateNotFound(error.Abort):
19770 0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	1317 pass
0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	1318
8218 e61cb2813d2a templater: separate template management and actual string processing Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8198 diff changeset	1319 class templater(object):
e61cb2813d2a templater: separate template management and actual string processing Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8198 diff changeset	1320
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1321 def __init__(self, filters=None, defaults=None, cache=None, aliases=(),
7396 526c40a74bd0 templater: return data in increasing chunk sizes Brendan Cully <brendan@kublai.com> parents: 7107 diff changeset	1322 minchunk=1024, maxchunk=65536):
1909 37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1323 '''set up template engine.
37b9f80a5fbb add doc comments to template code. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1906 diff changeset	1324 filters is dict of functions. each transforms a value into another.
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1325 defaults is dict of default map definitions.
d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1326 aliases is list of alias (name, replacement) pairs.
d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1327 '''
26332 66221730d372 templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26331 diff changeset	1328 if filters is None:
66221730d372 templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26331 diff changeset	1329 filters = {}
26333 727d57e94cda templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26332 diff changeset	1330 if defaults is None:
727d57e94cda templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26332 diff changeset	1331 defaults = {}
26334 0a5a774f5956 templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26333 diff changeset	1332 if cache is None:
0a5a774f5956 templater: remove a mutable default argument Pierre-Yves David <pierre-yves.david@fb.com> parents: 26333 diff changeset	1333 cache = {}
1975 6e1a8ea5d717 Duplicate cache when creating templater. Shun-ichi Goto <shunichi.goto@gmail.com> parents: 1964 diff changeset	1334 self.cache = cache.copy()
1896 f8f818a04f5b move hgweb template code out to templater Vadim Gelfer <vadim.gelfer@gmail.com> parents: diff changeset	1335 self.map = {}
8360 acc202b71619 templater: provide the standard template filters by default Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8312 diff changeset	1336 self.filters = templatefilters.filters.copy()
acc202b71619 templater: provide the standard template filters by default Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8312 diff changeset	1337 self.filters.update(filters)
1964 778281d46bb2 fix template bug that made hgweb break. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1955 diff changeset	1338 self.defaults = defaults
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1339 self._aliases = aliases
7396 526c40a74bd0 templater: return data in increasing chunk sizes Brendan Cully <brendan@kublai.com> parents: 7107 diff changeset	1340 self.minchunk, self.maxchunk = minchunk, maxchunk
13187 e3b87fb34d00 templater: clarify engine caching Matt Mackall <mpm@selenic.com> parents: 13176 diff changeset	1341 self.ecache = {}
1896 f8f818a04f5b move hgweb template code out to templater Vadim Gelfer <vadim.gelfer@gmail.com> parents: diff changeset	1342
28954 f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1343 @classmethod
f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1344 def frommapfile(cls, mapfile, filters=None, defaults=None, cache=None,
f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1345 minchunk=1024, maxchunk=65536):
f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1346 """Create templater from the specified map file"""
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1347 t = cls(filters, defaults, cache, [], minchunk, maxchunk)
28953 7f6b8ec691e3 templater: extract function that loads template map file Yuya Nishihara <yuya@tcha.org> parents: 28952 diff changeset	1348 cache, tmap = _readmapfile(mapfile)
28954 f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1349 t.cache.update(cache)
f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1350 t.map = tmap
f97a0bcfd7a1 templater: separate function to create templater from map file (API) Yuya Nishihara <yuya@tcha.org> parents: 28953 diff changeset	1351 return t
1896 f8f818a04f5b move hgweb template code out to templater Vadim Gelfer <vadim.gelfer@gmail.com> parents: diff changeset	1352
1899 888d298ddb91 many small changes to templater. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1897 diff changeset	1353 def __contains__(self, key):
3637 e7639888bb2f templater: simplify cache and remove filter argument in __call__ Matt Mackall <mpm@selenic.com> parents: 3636 diff changeset	1354 return key in self.cache or key in self.map
1899 888d298ddb91 many small changes to templater. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1897 diff changeset	1355
8218 e61cb2813d2a templater: separate template management and actual string processing Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8198 diff changeset	1356 def load(self, t):
6783 6d824dc86907 templater: make a template a string-only iterator Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 6434 diff changeset	1357 '''Get the template for the given template name. Use a local cache.'''
16686 67964cda8701 cleanup: "not x in y" -> "x not in y" Brodie Rao <brodie@sf.io> parents: 14944 diff changeset	1358 if t not in self.cache:
1905 0c760737b996 improve template errors when something is wrong. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1904 diff changeset	1359 try:
14168 135e244776f0 prevent transient leaks of file handle by using new helper functions Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13665 diff changeset	1360 self.cache[t] = util.readfile(self.map[t][1])
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25654 diff changeset	1361 except KeyError as inst:
19770 0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	1362 raise TemplateNotFound(_('"%s" not in template map') %
0361163efbaf templater: support using templates with non-standard names from map file Alexander Plavin <alexander@plav.in> parents: 19390 diff changeset	1363 inst.args[0])
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25654 diff changeset	1364 except IOError as inst:
1905 0c760737b996 improve template errors when something is wrong. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 1904 diff changeset	1365 raise IOError(inst.args[0], _('template file %s: %s') %
8361 d8c5a7f25a40 templater: make the templating engine pluggable to some extent Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8360 diff changeset	1366 (self.map[t][1], inst.args[1]))
6783 6d824dc86907 templater: make a template a string-only iterator Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 6434 diff changeset	1367 return self.cache[t]
1896 f8f818a04f5b move hgweb template code out to templater Vadim Gelfer <vadim.gelfer@gmail.com> parents: diff changeset	1368
32891 2ecce24dfcd3 templater: add simple interface for unnamed template (API) Yuya Nishihara <yuya@tcha.org> parents: 32704 diff changeset	1369 def render(self, mapping):
2ecce24dfcd3 templater: add simple interface for unnamed template (API) Yuya Nishihara <yuya@tcha.org> parents: 32704 diff changeset	1370 """Render the default unnamed template and return result as string"""
2ecce24dfcd3 templater: add simple interface for unnamed template (API) Yuya Nishihara <yuya@tcha.org> parents: 32704 diff changeset	1371 return stringify(self('', **mapping))
2ecce24dfcd3 templater: add simple interface for unnamed template (API) Yuya Nishihara <yuya@tcha.org> parents: 32704 diff changeset	1372
10847 90f4367535a5 templater: map -> mapping Matt Mackall <mpm@selenic.com> parents: 10846 diff changeset	1373 def __call__(self, t, **mapping):
33032 4e6dc34b5d7a py3: convert kwargs keys' back to bytes using pycompat.byteskwargs() Pulkit Goyal <7895pulkit@gmail.com> parents: 32992 diff changeset	1374 mapping = pycompat.byteskwargs(mapping)
8361 d8c5a7f25a40 templater: make the templating engine pluggable to some extent Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8360 diff changeset	1375 ttype = t in self.map and self.map[t][0] or 'default'
13187 e3b87fb34d00 templater: clarify engine caching Matt Mackall <mpm@selenic.com> parents: 13176 diff changeset	1376 if ttype not in self.ecache:
28831 6b86ce3e3576 templater: give better error message for invalid engine type Yuya Nishihara <yuya@tcha.org> parents: 28696 diff changeset	1377 try:
6b86ce3e3576 templater: give better error message for invalid engine type Yuya Nishihara <yuya@tcha.org> parents: 28696 diff changeset	1378 ecls = engines[ttype]
6b86ce3e3576 templater: give better error message for invalid engine type Yuya Nishihara <yuya@tcha.org> parents: 28696 diff changeset	1379 except KeyError:
6b86ce3e3576 templater: give better error message for invalid engine type Yuya Nishihara <yuya@tcha.org> parents: 28696 diff changeset	1380 raise error.Abort(_('invalid template engine: %s') % ttype)
28957 d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1381 self.ecache[ttype] = ecls(self.load, self.filters, self.defaults,
d813132ea361 templater: load and expand aliases by template engine (API) (issue4842) Yuya Nishihara <yuya@tcha.org> parents: 28956 diff changeset	1382 self._aliases)
13187 e3b87fb34d00 templater: clarify engine caching Matt Mackall <mpm@selenic.com> parents: 13176 diff changeset	1383 proc = self.ecache[ttype]
8361 d8c5a7f25a40 templater: make the templating engine pluggable to some extent Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8360 diff changeset	1384
10847 90f4367535a5 templater: map -> mapping Matt Mackall <mpm@selenic.com> parents: 10846 diff changeset	1385 stream = proc.process(t, mapping)
7396 526c40a74bd0 templater: return data in increasing chunk sizes Brendan Cully <brendan@kublai.com> parents: 7107 diff changeset	1386 if self.minchunk:
526c40a74bd0 templater: return data in increasing chunk sizes Brendan Cully <brendan@kublai.com> parents: 7107 diff changeset	1387 stream = util.increasingchunks(stream, min=self.minchunk,
526c40a74bd0 templater: return data in increasing chunk sizes Brendan Cully <brendan@kublai.com> parents: 7107 diff changeset	1388 max=self.maxchunk)
526c40a74bd0 templater: return data in increasing chunk sizes Brendan Cully <brendan@kublai.com> parents: 7107 diff changeset	1389 return stream
7434 cf7741aa1e96 kill some trailing spaces Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7396 diff changeset	1390
22634 e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1391 def templatepaths():
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1392 '''return locations used for template files.'''
22636 d844e220792a templater: don't search randomly for templates - trust util.datapath Mads Kiilerich <madski@unity3d.com> parents: 22635 diff changeset	1393 pathsrel = ['templates']
22635 660861a6fad4 templater: inline global 'path' list in templatepaths Mads Kiilerich <madski@unity3d.com> parents: 22634 diff changeset	1394 paths = [os.path.normpath(os.path.join(util.datapath, f))
660861a6fad4 templater: inline global 'path' list in templatepaths Mads Kiilerich <madski@unity3d.com> parents: 22634 diff changeset	1395 for f in pathsrel]
660861a6fad4 templater: inline global 'path' list in templatepaths Mads Kiilerich <madski@unity3d.com> parents: 22634 diff changeset	1396 return [p for p in paths if os.path.isdir(p)]
2189 e3eba577a0ae move changeset_templater into templater module. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2001 diff changeset	1397
22634 e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1398 def templatepath(name):
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1399 '''return location of template file. returns None if not found.'''
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1400 for p in templatepaths():
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1401 f = os.path.join(p, name)
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1402 if os.path.exists(f):
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1403 return f
e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1404 return None
2189 e3eba577a0ae move changeset_templater into templater module. Vadim Gelfer <vadim.gelfer@gmail.com> parents: 2001 diff changeset	1405
9842 d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1406 def stylemap(styles, paths=None):
7966 aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1407 """Return path to mapfile for a given style.
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1408
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1409 Searches mapfile in the following locations:
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1410 1. templatepath/style/map
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1411 2. templatepath/map-style
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1412 3. templatepath/map
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1413 """
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1414
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1415 if paths is None:
22634 e48a5d3996c2 templater: introduce templatepaths for getting paths searched for templates Mads Kiilerich <madski@unity3d.com> parents: 22633 diff changeset	1416 paths = templatepaths()
7966 aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1417 elif isinstance(paths, str):
8223 02145b700fe4 templater: fix little problem from stylemap() changes Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8218 diff changeset	1418 paths = [paths]
7966 aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1419
9842 d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1420 if isinstance(styles, str):
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1421 styles = [styles]
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1422
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1423 for style in styles:
24296 b73a22d1d9bf hgweb: prevent loading style map from directories other than specified paths Yuya Nishihara <yuya@tcha.org> parents: 23167 diff changeset	1424 # only plain name is allowed to honor template paths
b73a22d1d9bf hgweb: prevent loading style map from directories other than specified paths Yuya Nishihara <yuya@tcha.org> parents: 23167 diff changeset	1425 if (not style
b73a22d1d9bf hgweb: prevent loading style map from directories other than specified paths Yuya Nishihara <yuya@tcha.org> parents: 23167 diff changeset	1426 or style in (os.curdir, os.pardir)
30620 bb77654dc7ae py3: replace os.sep with pycompat.ossep (part 3 of 4) Pulkit Goyal <7895pulkit@gmail.com> parents: 30342 diff changeset	1427 or pycompat.ossep in style
30630 bcf4a975f93d py3: replace os.altsep with pycompat.altsep Pulkit Goyal <7895pulkit@gmail.com> parents: 30620 diff changeset	1428 or pycompat.osaltsep and pycompat.osaltsep in style):
9842 d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1429 continue
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1430 locations = [os.path.join(style, 'map'), 'map-' + style]
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1431 locations.append('map')
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1432
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1433 for path in paths:
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1434 for location in locations:
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1435 mapfile = os.path.join(path, location)
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1436 if os.path.isfile(mapfile):
d3dbdca92458 hgweb: don't choke when an inexistent style is requested (issue1901) Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 9372 diff changeset	1437 return style, mapfile
7966 aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1438
aa983c3d94a9 templater: move stylemap function from hgweb to templater Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7434 diff changeset	1439 raise RuntimeError("No hgweb templates found in %r" % paths)
24601 d80819f67d59 templater: tell hggettext to collect help of template functions Yuya Nishihara <yuya@tcha.org> parents: 24586 diff changeset	1440
28695 cc103bd0dbf9 registrar: add templatefunc to mark a function as template function (API) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28687 diff changeset	1441 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	1442 """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	1443 """
cc103bd0dbf9 registrar: add templatefunc to mark a function as template function (API) FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28687 diff changeset	1444 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	1445 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	1446
24601 d80819f67d59 templater: tell hggettext to collect help of template functions Yuya Nishihara <yuya@tcha.org> parents: 24586 diff changeset	1447 # 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	1448 i18nfunctions = funcs.values()

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/templater.py @ 34335:dd28b1f55eb8