|
Server : Apache System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64 User : dh_edsupp ( 6597262) PHP Version : 8.2.26 Disable Function : NONE Directory : /lib/python3/dist-packages/mercurial/__pycache__/ |
Upload File : |
o
�]Lbі � @ s� d Z ddlmZmZ ddlZddlZddlmZ ddlm Z m
Z
ddl m Z m
Z
mZmZmZmZmZmZmZ ddlmZmZ i d d
�d d �d
d�dd�dd�dd�dd�dd�dd�dd �d d �d d �d!d"�d#d$�d%d&�d'd �Zd�d(d)�Zd�d+d,�Zd�d.d/�Zd�d0d1�Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+dRdS� Z,dTdU� Z-dVdW� Z.dXdY� Z/dZd[� Z0i d d\d]� �d#d^d]� �d!d_d]� �d%e'�d`dad]� �d e*�de(�d
e)�dbe-�dce/�dde0�dded]� �ddfd]� �dge+�ddhd]� �ddid]� �Z1e1�2� Z3e1d! e3d < G djdk� dkej4�Z5dldm� Z6dndo� Z7G dpdq� dqe8�Z9G drds� dse9�Z:G dtdu� due8�Z;dvdw� Z<dxdy� Z=dzd{� Z>G d|d}� d}e8�Z?G d~d� de8�Z@d�d�� ZAd�d�d��ZBd�d�d��ZCdS )�a� Slightly complicated template engine for commands and hgweb
This module provides low-level interface to the template engine. See the
formatter and cmdutil modules if you are looking for high-level functions
such as ``cmdutil.rendertemplate(ctx, tmpl)``.
Internal Data Types
-------------------
Template keywords and functions take a dictionary of current symbols and
resources (a "mapping") and return result. Inputs and outputs must be one
of the following data types:
bytes
a byte string, which is generally a human-readable text in local encoding.
generator
a lazily-evaluated byte string, which is a possibly nested generator of
values of any printable types, and will be folded by ``stringify()``
or ``flatten()``.
None
sometimes represents an empty value, which can be stringified to ''.
True, False, int, float
can be stringified as such.
wrappedbytes, wrappedvalue
a wrapper for the above printable types.
date
represents a (unixtime, offset) tuple.
hybrid
represents a list/dict of printable values, which can also be converted
to mappings by % operator.
hybriditem
represents a scalar printable value, also supports % operator.
revslist
represents a list of revision numbers.
mappinggenerator, mappinglist
represents mappings (i.e. a list of dicts), which may have default
output format.
mappingdict
represents a single mapping (i.e. a dict), which may have default output
format.
mappingnone
represents None of Optional[mappable], which will be mapped to an empty
string by % operation.
mappedgenerator
a lazily-evaluated list of byte strings, which is e.g. a result of %
operation.
� )�absolute_import�print_functionN� )�_)�FileNotFoundError�getattr) �config�encoding�error�parser�pycompat�templatefilters�
templatefuncs� templateutil�util)� resourceutil�
stringutil� ()� N)� groupr � ))� funcr r N� .)� NN)r r N� %)� NN)r r N� |)r NN)r r N� *)� NN)r r N� /)r NN)r r N� +)� NN)r r! N� -)r! N)� negate� )r" r! N� =)� NN)� keyvaluer& N� ,)� NN)� listr) Nr )r NNNN� integer)r r+ NNN� symbol)r r, NNN� string)r r- NNN� template)r r. NNN� endc c sV � |}t �| �} ||k �r�| | }|�� r�ny|dv r#|d|fV �nm|dv r@|d }t| |||�\}}d||fV |d8 }�nP|dkr�| ||d � dv r�| |d }|d }}||k r�| | }|d krk|d7 }qZ||krzd
| ||� |fV n|d7 }||k s^t�td �|���n|�� r�|}||k r�| | }|�� s�n|d7 }||k s�d | ||� |fV |d8 }n�|d kr�| ||d � d
v s�|dk�r=| ||d � dv �r=|dkr�|d7 }d
} nd} | ||d � }
|d }}||k �r4| �d||��r|d7 }q�| �|
||��r,t �
| ||� �}| dk�r!t|dt |��d }| ||fV |d7 }n|d7 }||k s�t�td �|��nS|� � �sG|dv �r{|}|d7 }||k �rj| | }|� � �sa|dk�san |d7 }||k �sR| ||� } d| |fV |d8 }n||k�r�dd|fV dS t�td�|��|d7 }||k s
|�r�t�td�|��dd|fV dS )z^Parse a template expression into a stream of tokens, which must end
with term if specifieds (=,).%|+-*/Ns "'r r. � rr) )s r's r"� \r- � unterminated stringr+ )s \'s \"r& )s r\'s r\"s \\\r! r � _r, r/ s syntax errors unterminated template expansion)
r �bytestr�isspace�_parsetemplater
�
ParseErrorr �isdigit�
startswithr � unescapestr�len�isalnum) �program�start�end�term�pos�c�s�data�d�token�quote�sym� rI �5/usr/lib/python3/dist-packages/mercurial/templater.py�tokenizeu s� �
�
��
��
�
�ZrK � c C st g }t | |||�D ]+\}}}|dkr|�||f� q |dkr$|�|� q |dkr.||f S t�d| ��t�d��)a�
>>> _parsetemplate(b'foo{bar}"baz', 0, 12)
([('string', 'foo'), ('symbol', 'bar'), ('string', '"baz')], 12)
>>> _parsetemplate(b'foo{bar}"baz', 0, 12, quote=b'"')
([('string', 'foo'), ('symbol', 'bar')], 9)
>>> _parsetemplate(b'foo"{bar}', 0, 9, quote=b'"')
([('string', 'foo')], 4)
>>> _parsetemplate(br'foo\"bar"baz', 0, 12, quote=b'"')
([('string', 'foo"'), ('string', 'bar')], 9)
>>> _parsetemplate(br'foo\\"bar', 0, 10, quote=b'"')
([('string', 'foo\\')], 6)
r- r. r/ s unexpected type: %s�! unterminated scanning of template)�
_scantemplate�appendr
�ProgrammingError)�tmplr> �stoprG �parsed�typ�valrA rI rI rJ r6 � s
r6 Fc c sV � d}t | dt| �|d�D ]\}}}|r||f V |dkr! dS ||f}q
t�d��)a Scan (type, start, end) positions of outermost elements in template
If raw=True, a backslash is not taken as an escape character just like
r'' string in Python. Note that this is different from r'' literal in
template in that no template fragment can appear in r'', e.g. r'{foo}'
is a literal '{foo}', but ('{foo}', raw=True) is a template expression
'foo'.
>>> list(scantemplate(b'foo{bar}"baz'))
[('string', 0, 3), ('template', 3, 8), ('string', 8, 12)]
>>> list(scantemplate(b'outer{"inner"}outer'))
[('string', 0, 5), ('template', 5, 14), ('string', 14, 19)]
>>> list(scantemplate(b'foo\\{escaped}'))
[('string', 0, 5), ('string', 5, 13)]
>>> list(scantemplate(b'foo\\{escaped}', raw=True))
[('string', 0, 4), ('template', 4, 13)]
Nr )�rawr/ rM )rN r; r
rP )rQ rV �lastrT rU rA rI rI rJ � scantemplate� s �
rX c
# s� � d| }t jtjg| }|� t � t�}z�� �k r�t� ��fdd�t�|�D �dd� d�}|dk r@d|�� �� �� fV �� n�||d � } d}
|s[|� t�� |� �d
�� }
|
d d krvd|�� |d � �| � fV |d � q|� kr�d|�� |� �� fV | |kr�d d
|d fV W d
S |� t
�|d �d��\} � �� d� �s�t �
td�� ��d| |fV � d 7 � � �k s|r�t �
td�|��W n t j
y� } zt| �� � d
} ~ ww d d
� fV d
S )zEParse template string into chunks of strings and template expressions� {c 3 s � | ]
}�� |� ��V qd S �N)�find)�.0rB �rA rR rQ rI rJ � <genexpr> s � z _scantemplate.<locals>.<genexpr>c S s | dk | fS )Nr rI )�nrI rI rJ �<lambda> s z _scantemplate.<locals>.<lambda>)�keyr r- r r1 r) r/ N� }�
invalid tokenr. r2 )r r: r �identity�elements�minr4 r; �rstrip�parserK r9 r
r7 r �_addparseerrorhint)
rQ r> rR rG rV �sepchars�unescape�pr_ rB �bs�parseres�instrI r] rJ rN sV �
� � �
��rN c C s\ | j d u rd S | j }|d |� �d�}|�dd�}|d d|d | d td� | _d S )N�
s \n� r s ^ s here)�location�count�replacer �hint)ro rQ �loc�offsetrI rI rJ ri = s
*ri c C s� t | t�s| S | d }|dkr |ftdd� | dd� D �� S t| �dks'J �tdd� | d D ��}|s6d S t|�dkrH|d d d
krH|d S |f| S ) a; Expand list of templates to node tuple
>>> def f(tree):
... print(pycompat.sysstr(prettyformat(_unnesttemplatelist(tree))))
>>> f((b'template', []))
(string '')
>>> f((b'template', [(b'string', b'foo')]))
(string 'foo')
>>> f((b'template', [(b'string', b'foo'), (b'symbol', b'rev')]))
(template
(string 'foo')
(symbol 'rev'))
>>> f((b'template', [(b'symbol', b'rev')])) # template(rev) -> str
(template
(symbol 'rev'))
>>> f((b'template', [(b'template', [(b'string', b'foo')])]))
(string 'foo')
r r. c s � � | ]}t |�V qd S rZ ��_unnesttemplatelist�r\ �xrI rI rJ r^ d � � z&_unnesttemplatelist.<locals>.<genexpr>r Nr) c s rx rZ ry r{ rI rI rJ r^ g r} )r- rL r- )�
isinstance�tupler; )�tree�op�xsrI rI rJ rz M s
rz c C s4 t | dt| ��\}}|t| �ksJ d��td|f�S )z Parse template string into treer s$ unquoted template should be consumedr. )r6 r; rz )rQ rS rA rI rI rJ rh p s rh c
C s2 zt | �W S tjy } zt|| � � d}~ww )a= Parse a template expression into tree
>>> parseexpr(b'"foo"')
('string', 'foo')
>>> parseexpr(b'foo(bar)')
('func', ('symbol', 'foo'), ('symbol', 'bar'))
>>> from . import error
>>> from . import pycompat
>>> try:
... parseexpr(b'foo(')
... except error.ParseError as e:
... pycompat.sysstr(e.message)
... e.location
'not a prefix: end'
4
>>> try:
... parseexpr(b'"foo" "bar"')
... except error.ParseError as e:
... pycompat.sysstr(e.message)
... e.location
'invalid token'
7
N)�
_parseexprr
r7 ri )�exprro rI rI rJ � parseexprw s
��r� c C sH t � t�}|�t| dt| ���\}}|t| �kr t�td�|��t|�S )Nr rc ) r re rh rK r; r
r7 r rz )r� rl r� rA rI rI rJ r� � s
r� c C s t �| d�S )N)r+ r- r, )r � prettyformat�r� rI rI rJ r� � s r� c C s( | s t �td���| d }|| | |�S )z1Compile parsed template tree to (func, data) pairs missing argumentr �r
r7 r )�exp�context�
curmethods�trI rI rJ �
compileexp� s r� c C s* | d dkr
| d S t �td�| d ��)Nr r, r s expected a symbol, got '%s'r� )r� rI rI rJ � getsymbol� s r� c C s0 | sg S | d dkrt | d �| d g S | gS )Nr r* r r) ��getlist)r| rI rI rJ r� � s
r� c C s@ | d dv r t | |t�S | d dkr|�| d �S t�td���)z_Compile given template tree or load named template from map file;
returns (func, data) pairr )r. r- r, r s expected template specifier)r� �methods�_loadr
r7 r �r� r� rI rI rJ � gettemplate� s
r� c C s t �td�| ��)Ns$ recursive reference '%s' in template)r
�
InputErrorr )r� �mappingra rI rI rJ �_runrecursivesymbol� s r� c s$ � fdd�| dd � D �}t j|fS )Nc s g | ]}t |� t��qS rI )r� r� )r\ �e�r� rI rJ �
<listcomp>� � z!buildtemplate.<locals>.<listcomp>r )r � runtemplate)r� r� �ctmplrI r� rJ �
buildtemplate� s
r� c C s� t | d �}||jv r |j| }t| d |t�}tj||ffS ||jv r8|j| }t| d |t||j�}||fS t �
t d�| ��)Nr) r � unknown function '%s') r� �_filtersr� r� r � runfilter�_funcs�_buildfuncargs�_argspecr
r7 r )r� r� r_ �filt�arg�f�argsrI rI rJ � buildfilter� s
r� c C s, t | d |t�}t| d |�}tj||ffS �Nr r) )r� r� r� r �runmap)r� r� �darg�targrI rI rJ �buildmap� s r� c C s* t | d |t�}t| d �}tj||ffS r� )r� r� r� r � runmember)r� r� r� �membrI rI rJ � buildmember� s r� c C s t | d |t�}tj|fS �Nr )r� � exprmethodsr � runnegate)r� r� r� rI rI rJ � buildnegate� s
r� c C s0 t | d |t�}t | d |t�}tj|||ffS r� )r� r� r �
runarithmetic)r� r� �func�left�rightrI rI rJ �buildarithmetic� s r� c C s� t | d �}||jv r |j| }t| d |t||j�}||fS ||jv rLt| d |t|d d�}t|�dkr>t�t d�| ��|j| }t
j |d |ffS t�t d�| ��)Nr r) )�argspecs filter %s expects one argumentr r� ) r� r� r� r� r� r� r; r
r7 r r r� )r� r� r_ r� r� rI rI rJ � buildfunc� s
r� c
s� � �fdd�}� �fdd�}|s|t | ��S t�|� \}}} }
}tjt | �||ddd�} t�� } |r<|| �|��| |< |
rG|| �|
��| |
< | �|| �� | S )a Compile parsed tree of function arguments into list or dict of
(func, data) pairs
>>> context = engine(lambda t: (templateutil.runsymbol, t))
>>> def fargs(expr, argspec):
... x = _parseexpr(expr)
... n = getsymbol(x[1])
... return _buildfuncargs(x[2], context, exprmethods, n, argspec)
>>> list(fargs(b'a(l=1, k=2)', b'k l m').keys())
['l', 'k']
>>> args = fargs(b'a(opts=1, k=2)', b'**opts')
>>> list(args.keys()), list(args[b'opts'].keys())
(['opts'], ['opts', 'k'])
c s t �� �fdd�t�| �D ��S )Nc 3 s$ � | ]
\}}|t |� ��fV qd S rZ �r� )r\ �kr| �r� r� rI rJ r^ s
� �
�z6_buildfuncargs.<locals>.compiledict.<locals>.<genexpr>)r �sortdictr � iteritems�r� r� rI rJ � compiledict s �z#_buildfuncargs.<locals>.compiledictc s � �fdd�| D �S )Nc s g | ]}t |� ���qS rI r� r{ r� rI rJ r� r� z7_buildfuncargs.<locals>.compilelist.<locals>.<listcomp>rI r� r� rI rJ � compilelist � z#_buildfuncargs.<locals>.compilelistr' r, )� keyvaluenode�keynode)r� r � splitargspec�
buildargsdictr r� �pop�update)
r� r� r� �funcnamer� r� r� �_poskeys�varkey�_keys�optkey�treeargs�compargsrI r� rJ r� s& �r� c C s t �td���)Ns* can't use a key-value pair in this contextr� )r� �contentrI rI rJ �buildkeyvaluepair3 s r� c C s t jtd�td�d��)Ns can't use a list in this contexts check place of comma and parens�ru r� r� rI rI rJ � buildlist7 s �r� c C � t j| d fS r� )r �
runinteger�r� rB rI rI rJ r` @ � r` c C r� r� )r � runstringr� rI rI rJ r` A r� c C r� r� )r � runsymbolr� rI rI rJ r` B r� r c C s t | d |t�S r� )r� r� r� rI rI rJ r` D � r r' r* c C � t | |dd� �S )Nc S s | | S rZ rI ��a�brI rI rJ r` K � �<lambda>.<locals>.<lambda>�r� r� rI rI rJ r` K r� c C r� )Nc S s | | S rZ rI r� rI rI rJ r` L r� r� r� r� rI rI rJ r` L r� r# c C r� )Nc S s | | S rZ rI r� rI rI rJ r` N r� r� r� r� rI rI rJ r` N r� c C r� )Nc S s | | S rZ rI r� rI rI rJ r` O r� r� r� r� rI rI rJ r` O r� c @ s, e Zd ZdZed�Zee�Zedd� �Z dS )� _aliasrulesz2Parsing and expansion rule set of template aliasess template aliasc C sn | d dkr| d d dkr| d d t | d �fS | d dkr3| d d dkr5| d d | d gfS dS dS )zNReturn (name, args) if tree is func(...) or ...|filter; otherwise
Noner r r r, r) r Nr� r� rI rI rJ � _trygetfunc] s
�z_aliasrules._trygetfuncN)
�__name__�
__module__� __qualname__�__doc__r �_section� staticmethodr� �_parser� rI rI rI rJ r� W s r� c C s t �|�}t �|| �S )z'Return new tree of aliases are expanded)r� r� �expand)r� �aliases�aliasmaprI rI rJ �
expandaliasesg s
r� c C s8 t | �dk s| d dvs| d | d kr| S | dd� S )z9unwrap quotes if any; otherwise returns unmodified stringr) r � '"���r )r; )rC rI rI rJ �
unquotestringp s ( r� c @ sN e Zd ZdZejZejdd� �Zejdd� �Z ejdd� �Z
ejdd � �Z d
S ) �resourcemapperz%Mapper of internal template resourcesc C � dS )�BReturn a set of available resource keys based on the given mappingNrI ��selfr� rI rI rJ �
availablekeys| � z resourcemapper.availablekeysc C r� )�'Return a set of supported resource keysNrI �r� rI rI rJ � knownkeys� r� zresourcemapper.knownkeysc C r� )z:Return a resource for the key if available; otherwise NoneNrI �r� r� ra rI rI rJ �lookup� r� zresourcemapper.lookupc C r� )zcReturn a dict of additional mapping items which should be paired
with the given new mappingNrI �r� r� � origmapping�
newmappingrI rI rJ � populatemap� r� zresourcemapper.populatemapN) r� r� r� r� �abc�ABCMeta�
__metaclass__�abstractmethodr� r� r r rI rI rI rJ r� w s
r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S )
�nullresourcemapperc C � t � S rZ ��setr� rI rI rJ r� � � z nullresourcemapper.availablekeysc C r
rZ r r� rI rI rJ r� � r
z nullresourcemapper.knownkeysc C s d S rZ rI r� rI rI rJ r � � znullresourcemapper.lookupc C s i S rZ rI r rI rI rJ r � r z nullresourcemapper.populatemapN)r� r� r� r� r� r r rI rI rI rJ r � s
r c @ sz e Zd ZdZd dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � ZdS ) �enginea� template expansion engine.
template expansion works like this. a map file contains key=value
pairs. if value is quoted, it is treated as string. otherwise, it
is treated as name of template file.
templater is asked to expand a key in map. it looks up key, and
looks for strings like this: {foo}. it expands {foo} by looking up
foo in map, and substituting it. expansion is recursive: it stops
when there is no more {foo} to replace.
expansion also allows formatting and filtering.
format uses key to expand each item in list. syntax is
{key%format}.
filter uses function to transform value. syntax is
{key|filter1|filter2|...}.Nc C sV || _ |d u r i }|| _tj| _|d u ri }|d u r t� }|| _|| _i | _i | _ d S rZ )
�_loaderr� r �funcsr� r � _defaults�
_resources�_cache�
_tmplcache)r� �loader�filters�defaults� resourcesrI rI rJ �__init__� s
zengine.__init__c sV �j �� � �j �|��� ��fdd�t�|�D �}|�|� |��j ��||�� |S )zfCreate combined mapping from the original mapping and partial
mapping to override the originalc s. i | ]\}}|� v s�� ��|��r||�qS rI )�
isdisjoint�_defaultrequires)r\ r� �v��knownres�newresr� rI rJ �
<dictcomp>� s ��z%engine.overlaymap.<locals>.<dictcomp>)r r� r� r r� r� r )r� r r r� rI r rJ �
overlaymap� s
�
�zengine.overlaymapc C s, | j �|�}|du st|�sdS t|dd�S )z?Resource keys required by the specified default symbol functionNrI � _requires)r �get�callabler )r� ra r rI rI rJ r � s zengine._defaultrequiresc C s4 d}|| j �� vr|�|�}|du r| j�|�}|S )z:Resolve symbol to value or function; None if nothing foundN)r r� r$ r �r� r� ra r rI rI rJ �symbol� s
z
engine.symbolc C � | j �|�S )r� )r r� r� rI rI rJ �availableresourcekeys� � z engine.availableresourcekeysc C s
| j �� S )r� )r r� r� rI rI rJ �knownresourcekeys� s
zengine.knownresourcekeysc C s, | j �||�}|du rt�td�| ��|S )zNReturn internal data (e.g. cache) used for keyword/function
evaluationNs# template resource not available: %s)r r r �ResourceUnavailabler r& rI rI rJ �resource� s
�zengine.resourcec C sT || j vr%| �|�}t|f| j |< z t|| t�| j |< W n | j |= � | j | S )z!load, parse, and cache a template)r r r� r� r� )r� r� r| rI rI rJ r� � s
z engine._loadc C s. || j vrt|�}t|| t�| j |< | j | S )z"Parse and cache a literal template)r rh r� r� �r� rQ r| rI rI rJ r� s
z
engine._parsec C s( z| � |� W dS tjy Y dS w )z:Load, parse, and cache the specified template if availableTF)r� r �TemplateNotFound�r� r� rI rI rJ �preload
s
�zengine.preloadc C � | � |�\}}| �|||�S )z�Perform expansion. t is name of map element to expand.
mapping contains added elements for use during expansion. Is a
generator.)r� �_expand)r� r� r� r� rD rI rI rJ �process s zengine.processc C r2 )z�Perform expansion over a literal template
No user aliases will be expanded since this is supposed to be called
with an internal template string.
)r� r3 )r� rQ r� r� rD rI rI rJ r� s z
engine.expandc C s8 | j �| i |�}|r|�|� |}t�| ||| ||��S rZ )r r r� r �flatten)r� r� rD r� � extramappingrI rI rJ r3 " s
zengine._expand)NNN)r� r� r� r� r r" r r' r) r+ r- r� r� r1 r4 r� r3 rI rI rI rJ r � s
r c C sj t � } | s td�S t�| �}g }|D ]}|�d�}|d dv r q|d dkr-|�|d � qd�t|��S ) Ns7 no templates found, try `hg debuginstall` for more infor r� )s origs rejr s map-cmdliner s , )� templatedirr �os�listdir�splitrO �join�sorted)�path�dirlist� stylelist�filer: rI rI rJ r? - s
�r? c C s8 t j�| �r t�| d�S tjtd�| td�t� d��)N� rbs style '%s' not founds available styles: %sr� ) r8 r= �existsr � posixfiler
�Abortr r? )�mapfilerI rI rJ �
_open_mapfile< s
�rF c
s� t jr|�t j�}d�|�}tj�|�� t�� �� ��fdd��| � � }�j
||ddi�d� i }i }g }�� dd�}|r�|d d vr�tj� tj�� |��}tj�
|�s�t� } | d
ur�tj� tj�| |��}
tj�|
�ro|
}ntj� tj�|
d ��} tj�| �r�| }t|�} t| |�\}}}��d�D ]@\} }|s�t�td ���d| ���|d d v r�|d |d
kr�t�td���d| ���t|�|| < q�| dkr�tj�� |�|| < q�|���d�� |||fS )z.Load template elements from the given map filer c s� d }� rt j�t j�� | ��}t j�|�rt�|d�}|sTtj| vr8| }zt �
d| �}W n' t y7 d }Y n w t � }|rTt j�t j�|| ��}t j�|�rTt�|d�}|rf|�
� }�j||||�d� d S d S )NrA s mercurial.templates)�sections�remap�include)r8 r= �normpathr; �isfiler rC r �ossepr �
open_resourcer r7 �readrh )�relrH rG � subresource�abs�dirrD ��base�confrI rI rJ rI Q s<
� �
��z _readmapfile.<locals>.includerL � templates)rH rI s __base__r r� Ns maps
missing valuer� s unmatched quotess
templatealias)r � iswindowsr: rL r; r8 r= �dirnamer rN rh r$ rJ rB r7 rK rF � _readmapfile�itemsr
r7 r �sourcer� �extend)
�fprE �
name_pathsrD �cache�tmapr� rU r= rR �p2�p3ra rI rS rJ rY E sR
� ��
rY c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )r z2Load template fragments optionally from a map filec C s, |d u ri }|� � | _i | _t�|�| _d S rZ )�copyr_ �_mapr� r� � _aliasmap)r� r_ r� rI rI rJ r � s
zloader.__init__c C s || j v p || jv S rZ )r_ rd �r� ra rI rI rJ � __contains__� r� zloader.__contains__c
C s� || j vrWzt| j| �\}}|�� | j |< W n? ty/ } z t�td�|jd ��d}~w t yV } z td�| j| t
� |jd �f }t |jd t �
|���d}~ww | �| j | �S )�?Get parsed tree for the given template name. Use a local cache.s "%s" not in template mapr Ns template file %s: %sr )r_ �
open_templaterd rN �KeyErrorr r/ r r� �IOErrorr � forcebytestrr � strfromlocalr� )r� r� rE r] ro �reasonrI rI rJ �load� s$
�����z loader.loadc C s t |�}| jrt�| j|�}|S rZ )rh re r� r� r. rI rI rJ r� � s z
loader._parsec C s� |sd S |d }|dkr4|d }||d v rd S |d � |� || jv s)|| jv r2| �| �|�|� d S |dv r:d S |dkrS|d � t|d �� | �|d |� d S |dkrl|d � t|d �� | �|d |� d S |dd � D ]}| �||� qrd S )Nr r, r > r- r+ r r) r )�addr_ rd �_findsymbolsusedro r� )r� r� �symsr� rC r| rI rI rJ rq � s0 �zloader._findsymbolsusedc C s" t � t � f}| �| �|�|� |S �z�Look up (keywords, filters/functions) referenced from the name
template 't'
This may load additional templates from the map file.
)r rq ro )r� r� rr rI rI rJ � symbolsused� s zloader.symbolsusedN)
r� r� r� r� r rg ro r� rq rt rI rI rI rJ r � s r c @ s� e Zd Z d dd�Ze d dd��Zd d
� Zed d � �Zed
d� �Z edd� �Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � ZdS ) � templaterNrI � � c C sJ t j�� }|r |�|� t||�| _t| jj|||�| _||| _ | _
dS )ag Create template engine optionally with preloaded template fragments
- ``filters``: a dict of functions to transform a value into another.
- ``defaults``: a dict of symbol values/functions; may be overridden
by a ``mapping`` dict.
- ``resources``: a resourcemapper object to look up internal data
(e.g. cache), inaccessible from user template.
- ``cache``: a dict of preloaded template fragments.
- ``aliases``: a list of alias (name, replacement) pairs.
self.cache may be updated later to register additional template
fragments.
N) r
r rc r� r r r ro �_proc� _minchunk� _maxchunk) r� r r r r_ r� �minchunk�maxchunk�
allfiltersrI rI rJ r � s
ztemplater.__init__c C sX | ||||g ||�} |st |�}t||�\}}
} | jj�|� |
| j_t�| �| j_| S )z,Create templater from the specified map file) rF rY r r_ r� rd r� r� re ) �clsrE r] r r r r_ r{ r| r� r` r� rI rI rJ � frommapfile s
ztemplater.frommapfilec C s
|| j v S rZ )r rf rI rI rJ rg s
ztemplater.__contains__c C � | j jS rZ )r r_ r� rI rI rJ r_ � ztemplater.cachec C r� rZ )rx r� r� rI rI rJ r� $ r� ztemplater._filtersc C r� rZ )rx r r� rI rI rJ r ( r� ztemplater.defaultsc C r( )rh )r ro r0 rI rI rJ ro , r* ztemplater.loadc C s
| � d�S )z�Look up (keywords, filters/functions) referenced from the default
unnamed template
This may load additional templates from the map file.
rL )rt r� rI rI rJ �symbolsuseddefault0 s
z templater.symbolsuseddefaultc C r( rs )r rt r0 rI rI rJ rt 8 s ztemplater.symbolsusedc C s | � d|�S )z?Render the default unnamed template and return result as stringrL )�renderr� rI rI rJ �
renderdefault@ r* ztemplater.renderdefaultc C s d� | �||��S )z?Render the specified named template and return result as stringrL )r; �generate)r� r� r� rI rI rJ r� D s ztemplater.renderc C s, | j �||�}| jrtj|| j| jd�}|S )zVReturn a generator that renders the specified named template and
yields chunks)rf �max)rx r4 ry r �increasingchunksrz )r� r� r� �streamrI rI rJ r� H s
�ztemplater.generate)NNNNrI rv rw )NNNNNrv rw )r� r� r� r � classmethodr rg �propertyr_ r� r ro r� rt r� r� r� rI rI rI rJ ru � s>
� �
ru c C s, t j�t j�tjd��} t j�| �r| S dS )z6return the directory used for template files, or None.rV N)r8 r= rJ r; r �datapath�isdir)r= rI rI rJ r7 S s r7 c C s� t j�| �s t j�| �r| t| dd�fS |du rt� }|dur.t j�|| �}|t|dd�fS tjr<| � tj
�}d�|�} | � d�}d�ddg|dd� �}| t � ||d �fS ) a
returns a file-like object for the given template, and its full path
If the name is a relative path and we're in a frozen binary, the template
will be read from the mercurial.templates package instead. The returned path
will then be the relative path.
�rb)�modeNr r s mercurialrV r� )
r8 r= rK �isabs�openr7 r; r rW r: rL r rM )�name� templatepathr� r^ �
name_parts� package_namerI rI rJ ri Y s
�ri c C s& zt | |�W S ttfy Y dS w )N)NN)ri �EnvironmentError� ImportError)r� r� rI rI rJ �try_open_template| s
�r� rZ )rL )F)rL F)Dr� �
__future__r r r r8 �i18nr r r r � r r r
r r
r r r �utilsr r re rK r6 rX rN ri rz rh r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rc r� �basealiasrulesr� r� r� �objectr� r r r? rF rY r ru r7 ri r� rI rI rI rJ �<module> s� < , ������� �
� � �
�����
d
-#
/�������� �
� � �
���� WKl
#