Xavier-Do
5594d8f191
One of the most costly part of a page loading when the ormcache is cold is computing the assets node, the unique identifier of an attachment to validate whether the existing attachment is still valid with the current version of the static files. This operation needs to glob assets path in the filesystem, get the modification date, check attachments, ... Right now this task is not really optimized and can take some time because of an excessive number of glob on the filesystem, unnecessary exists to define absolute path, double computation of file list and modified times when getting js and css bundle separately, ... A list of modifications mainly discussed in the pr message are made with this commit to speedup things. - split css and js unique - prepare api for an in memory glob - change api to propagate absolute path and meta information through `ir.asset._get_paths`-> _get_asset_paths -> `_get_asset_content` -> `AssetsBundle` closes odoo/odoo#121159 Signed-off-by: Xavier Dollé (xdo) <xdo@odoo.com>
2643 lines
114 KiB
Python
2643 lines
114 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
"""
|
|
================
|
|
IrQWeb / ir.qweb
|
|
================
|
|
|
|
Preamble
|
|
========
|
|
|
|
Technical documentation of the python operation of the rendering QWeb engine.
|
|
|
|
Templating
|
|
==========
|
|
|
|
QWeb is the primary templating engine used by Odoo. It is an XML templating
|
|
engine and used mostly to generate XML, HTML fragments and pages.
|
|
|
|
Template directives are specified as XML attributes prefixed with ``t-``,
|
|
for instance ``t-if`` for :ref:`reference/qweb/conditionals`, with elements
|
|
and other attributes being rendered directly.
|
|
|
|
To avoid element rendering, a placeholder element ``<t>`` is also available,
|
|
which executes its directive but doesn't generate any output in and of
|
|
itself.
|
|
|
|
To create new XML template, please see :doc:`QWeb Templates documentation
|
|
<https://www.odoo.com/documentation/master/developer/reference/frontend/qweb.html>`
|
|
|
|
Rendering process
|
|
=================
|
|
|
|
In **input** you have an XML template giving the corresponding input etree.
|
|
Each etree input nodes are used to generate a python function. This fonction is
|
|
called and will give the XML **output**.
|
|
The ``_compile`` method is responsible to generate the function from the
|
|
etree, that function is a python generator that yield one output line at a
|
|
time. This generator is consumed by ``_render``. The generated function is orm
|
|
cached.
|
|
|
|
For performance, the **compile time** (when input, XML template or template
|
|
id, is compiled into a function) is less important than the **rendering time**
|
|
(when the function is called with the different values). The generation of the
|
|
function is only done once (for a set of options, language, branding ...)
|
|
because it is cached orm
|
|
|
|
The output is in ``MarkupSafe`` format. ``MarkupSafe`` escapes characters so
|
|
text is safe to use in HTML and XML. Characters that have special meanings
|
|
are replaced so that they display as the actual characters. This mitigates
|
|
injection attacks, meaning untrusted user input can safely be displayed on a
|
|
page.
|
|
|
|
At **compile time**, each dynamic attribute ``t-*`` will be compiled into
|
|
specific python code. (For example ``<t t-out="5 + 5"/>`` will insert the
|
|
template "10" inside the output)
|
|
|
|
At **compile time**, each directive removes the dynamic attribute it uses from
|
|
the input node attributes. At the end of the compilation each input node, no
|
|
dynamic attributes must remain.
|
|
|
|
How the code works
|
|
==================
|
|
|
|
In the graphic below you can see theresume of the call of the methods performed
|
|
in the IrQweb class.
|
|
|
|
.. code-block:: rst
|
|
|
|
Odoo
|
|
┗━► _render (returns MarkupSafe)
|
|
┗━► _compile (returns function) ◄━━━━━━━━━━┓
|
|
┗━► _compile_node (returns code string array) ◄━━━━━━━━┓ ┃
|
|
┃ (skip the current node if found t-qweb-skip) ┃ ┃
|
|
┃ (add technical directives: t-tag-open, t-tag-close, t-inner-content) ┃ ┃
|
|
┃ ┃ ┃
|
|
┣━► _directives_eval_order (defined directive order) ┃ ┃
|
|
┣━► _compile_directives (loop) Consume all remaining directives ◄━━━┓ ┃ ┃
|
|
┃ ┃ (e.g.: to change the indentation) ┃ ┃ ┃
|
|
┃ ┣━► _compile_directive ┃ ┃ ┃
|
|
┃ ┃ ┗━► t-nocache ━━► _compile_directive_nocache ━┫ ┃ ┃
|
|
┃ ┃ ┗━► t-cache ━━► _compile_directive_cache ━┫ ┃ ┃
|
|
┃ ┃ ┗━► t-groups ━━► _compile_directive_groups ━┫ ┃ ┃
|
|
┃ ┃ ┗━► t-foreach ━━► _compile_directive_foreach ━┫ ┃ ┃
|
|
┃ ┃ ┗━► t-if ━━► _compile_directive_if ━┛ ┃ ┃
|
|
┃ ┃ ┗━► t-inner-content ━━► _compile_directive_inner_content ◄━━━━━┓ ━┛ ┃
|
|
┃ ┃ ┗━► t-options ━━► _compile_directive_options ┃ ┃
|
|
┃ ┃ ┗━► t-set ━━► _compile_directive_set ◄━━┓ ┃ ┃
|
|
┃ ┃ ┗━► t-call ━━► _compile_directive_call ━┛ ━┫ ━━━┛
|
|
┃ ┃ ┗━► t-att ━━► _compile_directive_att ┃
|
|
┃ ┃ ┗━► t-tag-open ━━► _compile_directive_open ◄━━┓ ┃
|
|
┃ ┃ ┗━► t-tag-close ━━► _compile_directive_close ◄━━┫ ┃
|
|
┃ ┃ ┗━► t-out ━━► _compile_directive_out ━┛ ━┫ ◄━━┓
|
|
┃ ┃ ┗━► t-field ━━► _compile_directive_field ┃ ━┫
|
|
┃ ┃ ┗━► t-esc ━━► _compile_directive_esc ┃ ━┛
|
|
┃ ┃ ┗━► t-* ━━► ... ┃
|
|
┃ ┃ ┃
|
|
┗━━┻━► _compile_static_node ━┛
|
|
|
|
|
|
The QWeb ``_render`` uses the function generated by the ``_compile`` method.
|
|
Each XML node will go through the ``_compile_node`` method. If the
|
|
node does not have dynamic directives or attributes (``_is_static_node``).
|
|
A ``static`` is a node without ``t-*`` attributes, does not require dynamic
|
|
rendering for its attributes.
|
|
If it's a ``static`` node, the ``_compile_static_node`` method is called,
|
|
otherwise it is the ``_compile_directives`` method after having prepared the
|
|
order for calling the directives using the ``_directives_eval_order`` method.
|
|
In the defined order, for each directive the method ``_compile_directive`` is
|
|
called which itself dispatches to the methods corresponding to the directives
|
|
``_compile_directive_[name of the directive]`` (for example: ``t-if`` =>
|
|
``_compile_directive_if``). After all ordered directives, the directives
|
|
attributes still present on the element are compiled.
|
|
|
|
The ``_post_processing_att`` method is used for the generation of rendering
|
|
attributes. If the attributes come from static XML template nodes then the
|
|
method is called only once when generating the render function. Otherwise the
|
|
method is called during each rendering.
|
|
|
|
Each expression is compiled by the method ``_compile_expr`` into a python
|
|
expression whose values are namespaced.
|
|
|
|
Directives
|
|
----------
|
|
|
|
``t-debug``
|
|
~~~~~~~~~~~
|
|
**Values**: ``pdb``, ``ipdb``, ``pudb``, ``wdb``
|
|
|
|
Activate the choosed debugger.
|
|
|
|
When dev mode is enabled this allows python developers to have access to the
|
|
state of variables being rendered. The code generated by the QWeb engine is
|
|
not accessible, only the variables (values, self) can be analyzed or the
|
|
methods that called the QWeb rendering.
|
|
|
|
``t-if``
|
|
~~~~~~~~
|
|
**Values**: python expression
|
|
|
|
|
|
Add an python ``if`` condition to the code string array, and call
|
|
``_compile_directives`` to level and add the code string array corresponding
|
|
to the other directives and content.
|
|
|
|
The structure of the dom is checked to possibly find a ``t-else`` or
|
|
``t-elif``. If these directives exist then the compilation is performed and
|
|
the nodes are marked not to be rendered twice.
|
|
|
|
At **rendering time** the other directives code and content will used only if
|
|
the expression is evaluated as truely.
|
|
|
|
The ``t-else``, ``t-elif`` and ``t-if`` are not compiled at the same time like
|
|
defined in ``_directives_eval_order`` method.
|
|
```
|
|
<t t-set="check" t-value="1"/>
|
|
<section t-if="False">10</section>
|
|
<span t-elif="check == 1" t-foreach="range(3)" t-as="check" t-esc="check"/>
|
|
|
|
<section t-if="False">10</section>
|
|
<div t-else="" t-if="check == 1" t-foreach="range(3)" t-as="check" t-esc="check"/>
|
|
|
|
Result:
|
|
|
|
<span>0</span>
|
|
<span>1</span>
|
|
<span>2</span>
|
|
|
|
<div>1</div>
|
|
```
|
|
|
|
``t-else``
|
|
~~~~~~~~~~
|
|
**Values**: nothing
|
|
|
|
Only validate the **input**, the compilation if inside the ``t-if`` directive.
|
|
|
|
``t-elif``
|
|
~~~~~~~~~~
|
|
**Values**: python expression
|
|
|
|
Only validate the **input**, the compilation if inside the ``t-if`` directive.
|
|
|
|
``t-groups`` (``groups`` is an alias)
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
**Values**: name of the allowed odoo user group, or preceded by ``!`` for
|
|
prohibited groups
|
|
|
|
The generated code uses ``user_has_groups`` Odoo method.
|
|
|
|
``t-foreach``
|
|
~~~~~~~~~~~~~
|
|
**Values**: an expression returning the collection to iterate on
|
|
|
|
This directive is used with ``t-as`` directive to defined the key name. The
|
|
directive will be converted into a ``for`` loop. In this loop, different values
|
|
are added to the dict (``values`` in the generated method) in addition to the
|
|
key defined by ``t-name``, these are (``*_value``, ``*_index``, ``*_size``,
|
|
``*_first``, ``*_last``).
|
|
|
|
``t-as``
|
|
~~~~~~~~
|
|
**Values**: key name
|
|
|
|
The compilation method only validates if ``t-as`` and ``t-foreach`` are on the
|
|
same node.
|
|
|
|
``t-options`` and ``t-options-*``
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
**Values**: python expression
|
|
|
|
It's use on the same node of another directive, it's used to configure the
|
|
other directive. Used on the same ``input node`` of the directives ``t-call``,
|
|
``t-field`` or ``t-out``.
|
|
|
|
Create a ``values['__qweb_options__']`` dict from the optional ``t-options``
|
|
expression and add each key-value ``t-options-key="expression value"`` to this
|
|
dict. (for example: ``t-options="{'widget': 'float'}"`` is equal to
|
|
``t-options-widget="'float'"``)
|
|
|
|
``t-att``, ``t-att-*`` and ``t-attf-*``
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
**Values**: python expression (or format string expression for ``t-attf-``)
|
|
|
|
Compile the attributes to create ``values['__qweb_attrs__']`` dictionary code
|
|
in the compiled function. Use the ``t-att`` expression and add each key-value
|
|
``t-att-key="expression value"`` to this dict. (for example:
|
|
``t-att="{'class': f'float_{1}'}"`` is equal to ``t-att-class="f'float_{1}'"``
|
|
and is equal to ``t-attf-class="float_{{1}}")
|
|
|
|
The attributes come from new namespaces, static elements (not preceded
|
|
by ``t-``) and dynamic attributes ``t-att``, attributes prefixed by ``t-att-``
|
|
(python expression) or ``t-attf`` (format string expression).
|
|
|
|
``t-call``
|
|
~~~~~~~~~~
|
|
**Values**: format string expression for template name
|
|
|
|
Serves the called template in place of the current ``t-call`` node.
|
|
|
|
Here are the different steps performed by the generated python code:
|
|
|
|
#. copy the ``values`` dictionary;
|
|
#. render the content (``_compile_directive_inner_content``) of the tag in a
|
|
separate method called with the previous copied values. This values can be
|
|
updated via t-set. The visible content of the rendering of the sub-content
|
|
is added as a magical value ``0`` (can be rendered with ``t-out="0"``);
|
|
#. copy the ``compile_context`` dictionary;
|
|
#. compile the directive ``t-options`` and update the ``compile_context``
|
|
are, in added to the calling template and the ``nsmap`` values;
|
|
#. get the compiled function from the ``_compile`` method;
|
|
#. use the compiled function to serves the called template.
|
|
|
|
``t-lang``
|
|
~~~~~~~~~~
|
|
**Values**: python expression
|
|
|
|
Used to serve the called template (``t-call``) in another language. Used
|
|
together with ``t-call``.
|
|
|
|
This directive will be evaluate like ``t-options-lang``. Allows you to change
|
|
the language in which the called template is rendered. It's in the ``t-call``
|
|
directive that the language of the context of the ``ir.qweb`` recordset on
|
|
which the ``_compile`` function is called is updated.
|
|
|
|
``t-call-assets``
|
|
~~~~~~~~~~~~~~~~~
|
|
**Values**: format string for template name
|
|
|
|
The generated code call the ``_get_asset_nodes`` method to get the list of
|
|
(tagName, attrs and content). From each tuple a tag is created into the
|
|
rendering.
|
|
|
|
``t-out``
|
|
~~~~~~~~~
|
|
**Values**: python expression
|
|
|
|
Output the given value or if falsy, display the content as default value.
|
|
(for example: ``<t t-out="given_value">Default content</t>``)
|
|
|
|
The generated code add the value into the ``MarkupSafe`` rendering.
|
|
If a widget is defined (``t-options-widget``), the generated code call the
|
|
``_get_widget`` method to have the formatted field value and attributes. It's
|
|
the ``ir.qweb.field.*`` models that format the value.
|
|
|
|
``t-field``
|
|
~~~~~~~~~~~
|
|
**Values**: String representing the path to the field. (for example:
|
|
``t-field="record.name"``)
|
|
|
|
Output the field value or if falsy, display the content as default value.
|
|
(for example: ``<span t-field="record.name">Default content</span>``)
|
|
|
|
Use ``t-out`` compile method but the generated code call ``_get_field``
|
|
instead of ``_get_widget``. It's the ``ir.qweb.field.*`` models that format
|
|
the value. The rendering model is chosen according to the type of field. The
|
|
rendering model can be modified via the ``t-options-widget``.
|
|
|
|
``t-esc``
|
|
~~~~~~~~~
|
|
Deprecated, please use ``t-out``
|
|
|
|
``t-raw``
|
|
~~~~~~~~~
|
|
Deprecated, please use ``t-out``
|
|
|
|
``t-set``
|
|
~~~~~~~~~
|
|
**Values**: key name
|
|
|
|
The generated code update the key ``values`` dictionary equal to the value
|
|
defined by ``t-value`` expression, ``t-valuef`` format string expression or
|
|
to the ``MarkupSafe`` rendering come from the content of the node.
|
|
|
|
``t-value``
|
|
~~~~~~~~~~~
|
|
**Values**: python expression
|
|
|
|
The compilation method only validates if ``t-value`` and ``t-set`` are on the
|
|
same node.
|
|
|
|
``t-valuef``
|
|
~~~~~~~~~~~~
|
|
**Values**: format string expression
|
|
|
|
The compilation method only validates if ``t-valuef`` and ``t-set`` are on the
|
|
same node.
|
|
|
|
Technical directives
|
|
--------------------
|
|
|
|
Directive added automatically by IrQweb in order to go through the compilation
|
|
methods.
|
|
|
|
``t-tag-open``
|
|
~~~~~~~~~~~~~~
|
|
Used to generate the opening HTML/XML tags.
|
|
|
|
``t-tag-close``
|
|
~~~~~~~~~~~~~~
|
|
Used to generate the closing HTML/XML tags.
|
|
|
|
``t-inner-content``
|
|
~~~~~~~~~~~~~~~~~~~
|
|
Used to add the content of the node (text, tail and children nodes).
|
|
If namespaces are declared on the current element then a copy of the options
|
|
is made.
|
|
|
|
``t-consumed-options``
|
|
~~~~~~~~~~~~~~~~~~~~~~
|
|
Raise an exception if the ``t-options`` is not consumed.
|
|
|
|
``t-qweb-skip``
|
|
~~~~~~~~~~~~~~~~~~~~~~
|
|
Ignore rendering and directives for the curent **input** node.
|
|
|
|
``t-else-valid``
|
|
~~~~~~~~~~~~~~~~~~~~~~
|
|
Mark a node with ``t-else`` or ``t-elif`` having a valid **input** dom
|
|
structure.
|
|
|
|
"""
|
|
|
|
import fnmatch
|
|
import io
|
|
import logging
|
|
import math
|
|
import re
|
|
import textwrap
|
|
import time
|
|
import token
|
|
import tokenize
|
|
import traceback
|
|
import werkzeug
|
|
|
|
from markupsafe import Markup, escape
|
|
from collections.abc import Sized, Mapping
|
|
from itertools import count, chain
|
|
from lxml import etree
|
|
from dateutil.relativedelta import relativedelta
|
|
from psycopg2.extensions import TransactionRollbackError
|
|
|
|
from odoo import api, models, tools
|
|
from odoo.tools import config, safe_eval, pycompat
|
|
from odoo.tools.constants import SUPPORTED_DEBUGGER, EXTERNAL_ASSET
|
|
from odoo.tools.safe_eval import assert_valid_codeobj, _BUILTINS, to_opcodes, _EXPR_OPCODES, _BLACKLIST
|
|
from odoo.tools.json import scriptsafe
|
|
from odoo.tools.misc import str2bool
|
|
from odoo.tools.image import image_data_uri
|
|
from odoo.http import request
|
|
from odoo.tools.profiler import QwebTracker
|
|
from odoo.exceptions import UserError, AccessDenied, AccessError, MissingError, ValidationError
|
|
|
|
from odoo.addons.base.models.assetsbundle import AssetsBundle
|
|
from odoo.tools.constants import SCRIPT_EXTENSIONS, STYLE_EXTENSIONS, TEMPLATE_EXTENSIONS
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
# QWeb token usefull for generate expression used in `_compile_expr_tokens` method
|
|
token.QWEB = token.NT_OFFSET - 1
|
|
token.tok_name[token.QWEB] = 'QWEB'
|
|
|
|
|
|
# security safe eval opcodes for generated expression validation, used in `_compile_expr`
|
|
_SAFE_QWEB_OPCODES = _EXPR_OPCODES.union(to_opcodes([
|
|
'MAKE_FUNCTION', 'CALL_FUNCTION', 'CALL_FUNCTION_KW', 'CALL_FUNCTION_EX',
|
|
'CALL_METHOD', 'LOAD_METHOD',
|
|
|
|
'GET_ITER', 'FOR_ITER', 'YIELD_VALUE',
|
|
'JUMP_FORWARD', 'JUMP_ABSOLUTE', 'JUMP_BACKWARD',
|
|
'JUMP_IF_FALSE_OR_POP', 'JUMP_IF_TRUE_OR_POP', 'POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',
|
|
|
|
'LOAD_NAME', 'LOAD_ATTR',
|
|
'LOAD_FAST', 'STORE_FAST', 'UNPACK_SEQUENCE',
|
|
'STORE_SUBSCR',
|
|
'LOAD_GLOBAL',
|
|
# Following opcodes were added in 3.11 https://docs.python.org/3/whatsnew/3.11.html#new-opcodes
|
|
'RESUME',
|
|
'CALL',
|
|
'PRECALL',
|
|
'POP_JUMP_FORWARD_IF_FALSE',
|
|
'PUSH_NULL',
|
|
'POP_JUMP_FORWARD_IF_TRUE', 'KW_NAMES',
|
|
'FORMAT_VALUE', 'BUILD_STRING',
|
|
'RETURN_GENERATOR',
|
|
'POP_JUMP_BACKWARD_IF_FALSE',
|
|
'SWAP',
|
|
])) - _BLACKLIST
|
|
|
|
|
|
# eval to compile generated string python code into binary code, used in `_compile`
|
|
unsafe_eval = eval
|
|
|
|
|
|
VOID_ELEMENTS = frozenset([
|
|
'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
|
|
'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])
|
|
# Terms allowed in addition to AVAILABLE_OBJECTS when compiling python expressions
|
|
ALLOWED_KEYWORD = frozenset(['False', 'None', 'True', 'and', 'as', 'elif', 'else', 'for', 'if', 'in', 'is', 'not', 'or'] + list(_BUILTINS))
|
|
# regexpr for string formatting and extract ( ruby-style )|( jinja-style ) used in `_compile_format`
|
|
FORMAT_REGEX = re.compile(r'(?:#\{(.+?)\})|(?:\{\{(.+?)\}\})')
|
|
RSTRIP_REGEXP = re.compile(r'\n[ \t]*$')
|
|
LSTRIP_REGEXP = re.compile(r'^[ \t]*\n')
|
|
FIRST_RSTRIP_REGEXP = re.compile(r'^(\n[ \t]*)+(\n[ \t])')
|
|
VARNAME_REGEXP = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*$')
|
|
TO_VARNAME_REGEXP = re.compile(r'[^A-Za-z0-9_]+')
|
|
# Attribute name used outside the context of the QWeb.
|
|
SPECIAL_DIRECTIVES = {'t-translation', 't-ignore', 't-title'}
|
|
# Name of the variable to insert the content in t-call in the template.
|
|
# The slot will be replaced by the `t-call` tag content of the caller.
|
|
T_CALL_SLOT = '0'
|
|
|
|
|
|
def indent_code(code, level):
|
|
"""Indent the code to respect the python syntax."""
|
|
return textwrap.indent(textwrap.dedent(code).strip(), ' ' * 4 * level)
|
|
|
|
|
|
def keep_query(*keep_params, **additional_params):
|
|
"""
|
|
Generate a query string keeping the current request querystring's parameters specified
|
|
in ``keep_params`` and also adds the parameters specified in ``additional_params``.
|
|
|
|
Multiple values query string params will be merged into a single one with comma seperated
|
|
values.
|
|
|
|
The ``keep_params`` arguments can use wildcards too, eg:
|
|
|
|
keep_query('search', 'shop_*', page=4)
|
|
"""
|
|
if not keep_params and not additional_params:
|
|
keep_params = ('*',)
|
|
params = additional_params.copy()
|
|
qs_keys = list(request.httprequest.args) if request else []
|
|
for keep_param in keep_params:
|
|
for param in fnmatch.filter(qs_keys, keep_param):
|
|
if param not in additional_params and param in qs_keys:
|
|
params[param] = request.httprequest.args.getlist(param)
|
|
return werkzeug.urls.url_encode(params)
|
|
|
|
####################################
|
|
### QWebException ###
|
|
####################################
|
|
|
|
class QWebException(Exception):
|
|
""" Management of errors that raised when rendering a QWeb template.
|
|
"""
|
|
def __init__(self, message, qweb, template=None, ref=None, path_xml=None, code=None):
|
|
self.stack = traceback.format_exc()
|
|
self.name = template
|
|
self.ref = ref
|
|
self.path, self.html = path_xml or (None, None)
|
|
self.code = None
|
|
if code:
|
|
self.code = '\n'.join(code.split('\n')[:-1]) if qweb.env.context.get('dev_mode') else None
|
|
line_nb = 0
|
|
for error_line in reversed(self.stack.split('\n')):
|
|
if f'File "<{self.ref}>"' in error_line:
|
|
line_function = error_line.split(', line ')[1]
|
|
line_nb = int(line_function.split(',')[0])
|
|
break
|
|
for code_line in reversed(code.split('\n')[:line_nb]):
|
|
match = re.match(r'\s*# element: (.*) , (.*)', code_line)
|
|
if match:
|
|
self.path = match[1][1:-1]
|
|
self.html = match[2][1:-1]
|
|
break
|
|
|
|
self.title = message
|
|
super().__init__(message)
|
|
|
|
def __str__(self):
|
|
parts = [self.title]
|
|
if self.__cause__ and str(self.__cause__) != '':
|
|
parts.append(f"{self.__cause__.__class__.__name__}: {self.__cause__}")
|
|
elif self.__context__ and str(self.__context__) != '':
|
|
parts.append(f"{self.__context__.__class__.__name__}: {self.__context__}")
|
|
if self.name is not None:
|
|
parts.append(f"Template: {self.name}")
|
|
if self.path is not None:
|
|
parts.append(f"Path: {self.path}")
|
|
if self.html is not None:
|
|
parts.append(f"Node: {self.html}")
|
|
if self.code is not None:
|
|
parts.append(f"Compiled code:\n{self.code}")
|
|
return "\n".join(parts)
|
|
|
|
def __repr__(self):
|
|
return f"QWebException({self.title!r})"
|
|
|
|
####################################
|
|
### QWeb ###
|
|
####################################
|
|
|
|
|
|
class IrQWeb(models.AbstractModel):
|
|
""" Base QWeb rendering engine
|
|
* to customize ``t-field`` rendering, subclass ``ir.qweb.field`` and
|
|
create new models called :samp:`ir.qweb.field.{widget}`
|
|
Beware that if you need extensions or alterations which could be
|
|
incompatible with other subsystems, you should create a local object
|
|
inheriting from ``ir.qweb`` and customize that.
|
|
"""
|
|
|
|
_name = 'ir.qweb'
|
|
_description = 'Qweb'
|
|
|
|
@QwebTracker.wrap_render
|
|
@api.model
|
|
def _render(self, template, values=None, **options):
|
|
""" render(template, values, **options)
|
|
|
|
Render the template specified by the given name.
|
|
|
|
:param template: etree, xml_id, template name (see _get_template)
|
|
* Call the method ``load`` is not an etree.
|
|
:param dict values: template values to be used for rendering
|
|
:param options: used to compile the template
|
|
Options will be add into the IrQweb.env.context for the rendering.
|
|
* ``lang`` (str) used language to render the template
|
|
* ``inherit_branding`` (bool) add the tag node branding
|
|
* ``inherit_branding_auto`` (bool) add the branding on fields
|
|
* ``minimal_qcontext``(bool) To use the minimum context and options
|
|
from ``_prepare_environment``
|
|
|
|
:returns: bytes marked as markup-safe (decode to :class:`markupsafe.Markup`
|
|
instead of `str`)
|
|
:rtype: MarkupSafe
|
|
"""
|
|
values = values.copy() if values else {}
|
|
if T_CALL_SLOT in values:
|
|
raise ValueError(f'values[{T_CALL_SLOT}] should be unset when call the _render method and only set into the template.')
|
|
|
|
irQweb = self.with_context(**options)._prepare_environment(values)
|
|
|
|
safe_eval.check_values(values)
|
|
|
|
template_functions, def_name = irQweb._compile(template)
|
|
render_template = template_functions[def_name]
|
|
rendering = render_template(irQweb, values)
|
|
result = ''.join(rendering)
|
|
|
|
return Markup(result)
|
|
|
|
# assume cache will be invalidated by third party on write to ir.ui.view
|
|
def _get_template_cache_keys(self):
|
|
""" Return the list of context keys to use for caching ``_compile``. """
|
|
return ['lang', 'inherit_branding', 'edit_translations', 'profile']
|
|
|
|
@tools.conditional(
|
|
'xml' not in tools.config['dev_mode'],
|
|
tools.ormcache('template', 'tuple(self.env.context.get(k) for k in self._get_template_cache_keys())'),
|
|
)
|
|
def _get_view_id(self, template):
|
|
try:
|
|
return self.env['ir.ui.view'].sudo().with_context(load_all_views=True)._get_view_id(template)
|
|
except Exception:
|
|
return None
|
|
|
|
@QwebTracker.wrap_compile
|
|
def _compile(self, template):
|
|
if isinstance(template, etree._Element):
|
|
self = self.with_context(is_t_cache_disabled=True)
|
|
ref = None
|
|
else:
|
|
ref = self._get_view_id(template)
|
|
|
|
# define the base key cache for code in cache and t-cache feature
|
|
base_key_cache = None
|
|
if ref:
|
|
base_key_cache = self._get_cache_key(tuple([ref] + [self.env.context.get(k) for k in self._get_template_cache_keys()]))
|
|
self = self.with_context(__qweb_base_key_cache=base_key_cache)
|
|
|
|
# generate the template functions and the root function name
|
|
def generate_functions():
|
|
code, options, def_name = self._generate_code(template)
|
|
profile_options = {
|
|
'ref': options.get('ref') and int(options['ref']) or None,
|
|
'ref_xml': options.get('ref_xml') and str(options['ref_xml']) or None,
|
|
} if self.env.context.get('profile') else None
|
|
code = '\n'.join([
|
|
"def generate_functions():",
|
|
" template_functions = {}",
|
|
indent_code(code, 1),
|
|
f" template_functions['options'] = {profile_options!r}",
|
|
" return template_functions",
|
|
])
|
|
|
|
try:
|
|
compiled = compile(code, f"<{ref}>", 'exec')
|
|
globals_dict = self._prepare_globals()
|
|
globals_dict['__builtins__'] = globals_dict # So that unknown/unsafe builtins are never added.
|
|
unsafe_eval(compiled, globals_dict)
|
|
return globals_dict['generate_functions'](), def_name
|
|
except QWebException:
|
|
raise
|
|
except Exception as e:
|
|
raise QWebException("Error when compiling xml template",
|
|
self, template, code=code, ref=ref) from e
|
|
|
|
return self._load_values(base_key_cache, generate_functions)
|
|
|
|
def _generate_code(self, template):
|
|
""" Compile the given template into a rendering function (generator)::
|
|
|
|
render_template(qweb, values)
|
|
This method can be called only by the IrQweb `_render` method or by
|
|
the compiled code of t-call from an other template.
|
|
|
|
An `options` dictionary is created and attached to the function. It
|
|
contains rendering options that are part of the cache key in
|
|
addition to template references.
|
|
|
|
where ``qweb`` is a QWeb instance and ``values`` are the values to
|
|
render.
|
|
|
|
:returns: tuple containing code, options and main method name
|
|
"""
|
|
# The `compile_context`` dictionary includes the elements used for the
|
|
# cache key to which are added the template references as well as
|
|
# technical information useful for generating the function. This
|
|
# dictionary is only used when compiling the template.
|
|
compile_context = self.env.context.copy()
|
|
|
|
try:
|
|
element, document, ref = self._get_template(template)
|
|
except (ValueError, UserError) as e:
|
|
# return the error function if the template is not found or fail
|
|
message = str(e)
|
|
code = indent_code(f"""
|
|
def not_found_template(self, values):
|
|
if self.env.context.get('raise_if_not_found', True):
|
|
raise {e.__class__.__name__}({message!r})
|
|
warning('Cannot load template %s: %s', {template!r}, {message!r})
|
|
return ''
|
|
template_functions = {{'not_found_template': not_found_template}}
|
|
""", 0)
|
|
return (code, {}, 'not_found_template')
|
|
|
|
compile_context.pop('raise_if_not_found', None)
|
|
|
|
# reference to get xml and etree (usually the template ID)
|
|
compile_context['ref'] = ref
|
|
# reference name or key to get xml and etree (usually the template XML ID)
|
|
compile_context['ref_name'] = element.attrib.pop('t-name', template if isinstance(template, str) and '<' not in template else None)
|
|
# str xml of the reference template used for compilation. Useful for debugging, dev mode and profiling.
|
|
compile_context['ref_xml'] = document
|
|
# Identifier used to call `_compile`
|
|
compile_context['template'] = template
|
|
# Root of the etree which will be processed during compilation.
|
|
compile_context['root'] = element.getroottree()
|
|
# Reference to the last node being compiled. It is mainly used for debugging and displaying error messages.
|
|
compile_context['_qweb_error_path_xml'] = None
|
|
|
|
if not compile_context.get('nsmap'):
|
|
compile_context['nsmap'] = {}
|
|
|
|
# The options dictionary includes cache key elements and template
|
|
# references. It will be attached to the generated function. This
|
|
# dictionary is only there for logs, performance or test information.
|
|
# The values of these `options` cannot be changed and must always be
|
|
# identical in `context` and `self.env.context`.
|
|
options = {k: compile_context.get(k) for k in self._get_template_cache_keys() + ['ref', 'ref_name', 'ref_xml']}
|
|
|
|
# generate code
|
|
|
|
def_name = TO_VARNAME_REGEXP.sub(r'_', f'template_{ref}')
|
|
|
|
name_gen = count()
|
|
compile_context['make_name'] = lambda prefix: f"{def_name}_{prefix}_{next(name_gen)}"
|
|
|
|
try:
|
|
if element.text:
|
|
element.text = FIRST_RSTRIP_REGEXP.sub(r'\2', element.text)
|
|
|
|
compile_context['template_functions'] = {}
|
|
|
|
compile_context['_text_concat'] = []
|
|
self._append_text("", compile_context) # To ensure the template function is a generator and doesn't become a regular function
|
|
compile_context['template_functions'][f'{def_name}_content'] = (
|
|
[f"def {def_name}_content(self, values):"]
|
|
+ self._compile_node(element, compile_context, 2)
|
|
+ self._flush_text(compile_context, 2, rstrip=True))
|
|
|
|
compile_context['template_functions'][def_name] = [indent_code(f"""
|
|
def {def_name}(self, values):
|
|
try:
|
|
if '__qweb_loaded_values' not in values:
|
|
values['__qweb_loaded_values'] = {{}}
|
|
values['__qweb_root_values'] = values.copy()
|
|
values['xmlid'] = {options['ref_name']!r}
|
|
values['viewid'] = {options['ref']!r}
|
|
values['__qweb_loaded_values'].update(template_functions)
|
|
|
|
yield from {def_name}_content(self, values)
|
|
except QWebException:
|
|
raise
|
|
except Exception as e:
|
|
if isinstance(e, TransactionRollbackError):
|
|
raise
|
|
raise QWebException("Error while render the template",
|
|
self, template, ref={compile_context['ref']!r}, code=code) from e
|
|
""", 0)]
|
|
except QWebException:
|
|
raise
|
|
except Exception as e:
|
|
raise QWebException("Error when compiling xml template",
|
|
self, template, ref=compile_context['ref'], path_xml=compile_context['_qweb_error_path_xml']) from e
|
|
|
|
code_lines = ['code = None']
|
|
code_lines.append(f'template = {(document if isinstance(template, etree._Element) else template)!r}')
|
|
code_lines.append('template_functions = {}')
|
|
|
|
for lines in compile_context['template_functions'].values():
|
|
code_lines.extend(lines)
|
|
|
|
for name in compile_context['template_functions']:
|
|
code_lines.append(f'template_functions[{name!r}] = {name}')
|
|
|
|
code = '\n'.join(code_lines)
|
|
code += f'\n\ncode = {code!r}'
|
|
|
|
return (code, options, def_name)
|
|
|
|
# read and load input template
|
|
|
|
def _get_template(self, template):
|
|
""" Retrieve the given template, and return it as a tuple ``(etree,
|
|
xml, ref)``, where ``element`` is an etree, ``document`` is the
|
|
string document that contains ``element``, and ``ref`` if the uniq
|
|
reference of the template (id, t-name or template).
|
|
|
|
:param template: template identifier or etree
|
|
"""
|
|
assert template not in (False, None, ""), "template is required"
|
|
|
|
# template is an xml etree already
|
|
if isinstance(template, etree._Element):
|
|
element = template
|
|
document = etree.tostring(template, encoding='unicode')
|
|
ref = None
|
|
# template is xml as string
|
|
elif isinstance(template, str) and '<' in template:
|
|
raise ValueError('Inline templates must be passed as `etree` documents')
|
|
|
|
# template is (id or ref) to a database stored template
|
|
else:
|
|
try:
|
|
ref_alias = int(template) # e.g. <t t-call="33"/>
|
|
except ValueError:
|
|
ref_alias = template # e.g. web.layout
|
|
|
|
doc_or_elem, ref = self._load(ref_alias) or (None, None)
|
|
if doc_or_elem is None:
|
|
raise ValueError(f"Can not load template: {ref_alias!r}")
|
|
if isinstance(doc_or_elem, etree._Element):
|
|
element = doc_or_elem
|
|
document = etree.tostring(doc_or_elem, encoding='unicode')
|
|
elif isinstance(doc_or_elem, str):
|
|
element = etree.fromstring(doc_or_elem)
|
|
document = doc_or_elem
|
|
else:
|
|
raise TypeError(f"Loaded template {ref!r} should be a string.")
|
|
|
|
# return etree, document and ref, or try to find the ref
|
|
if ref:
|
|
return (element, document, ref)
|
|
|
|
# <templates>
|
|
# <template t-name=... /> <!-- return ONLY this element -->
|
|
# <template t-name=... />
|
|
# </templates>
|
|
for node in element.iter():
|
|
ref = node.get('t-name')
|
|
if ref:
|
|
return (node, document, ref)
|
|
|
|
# use the document itself as ref when no t-name was found
|
|
return (element, document, document)
|
|
|
|
def _load(self, ref):
|
|
"""
|
|
Load the template referenced by ``ref``.
|
|
|
|
:returns: The loaded template (as string or etree) and its
|
|
identifier
|
|
:rtype: Tuple[Union[etree, str], Optional[str, int]]
|
|
"""
|
|
IrUIView = self.env['ir.ui.view'].sudo()
|
|
view = IrUIView._get(ref)
|
|
template = IrUIView._read_template(view.id)
|
|
etree_view = etree.fromstring(template)
|
|
|
|
xmlid = view.key or ref
|
|
if isinstance(ref, int):
|
|
domain = [('model', '=', 'ir.ui.view'), ('res_id', '=', view.id)]
|
|
model_data = self.env['ir.model.data'].sudo().search_read(domain, ['module', 'name'], limit=1)
|
|
if model_data:
|
|
xmlid = f"{model_data[0]['module']}.{model_data[0]['name']}"
|
|
|
|
# QWeb's ``_read_template`` will check if one of the first children of
|
|
# what we send to it has a "t-name" attribute having ``ref`` as value
|
|
# to consider it has found it. As it'll never be the case when working
|
|
# with view ids or children view or children primary views, force it here.
|
|
if view.inherit_id is not None:
|
|
for node in etree_view:
|
|
if node.get('t-name') == str(ref) or node.get('t-name') == str(view.key):
|
|
node.attrib.pop('name', None)
|
|
node.attrib.pop('id', None)
|
|
etree_view = node
|
|
break
|
|
etree_view.set('t-name', str(xmlid))
|
|
return (etree_view, view.id)
|
|
|
|
# values for running time
|
|
|
|
def _prepare_environment(self, values):
|
|
""" Prepare the values and context that will sent to the
|
|
compiled and evaluated function.
|
|
|
|
:param values: template values to be used for rendering
|
|
|
|
:returns self (with new context)
|
|
"""
|
|
debug = request and request.session.debug or ''
|
|
values.update(
|
|
true=True,
|
|
false=False,
|
|
)
|
|
if not self.env.context.get('minimal_qcontext'):
|
|
values.setdefault('debug', debug)
|
|
values.setdefault('user_id', self.env.user.with_env(self.env))
|
|
values.setdefault('res_company', self.env.company.sudo())
|
|
|
|
values.update(
|
|
request=request, # might be unbound if we're not in an httprequest context
|
|
test_mode_enabled=bool(config['test_enable'] or config['test_file']),
|
|
json=scriptsafe,
|
|
quote_plus=werkzeug.urls.url_quote_plus,
|
|
time=safe_eval.time,
|
|
datetime=safe_eval.datetime,
|
|
relativedelta=relativedelta,
|
|
image_data_uri=image_data_uri,
|
|
# specific 'math' functions to ease rounding in templates and lessen controller marshmalling
|
|
floor=math.floor,
|
|
ceil=math.ceil,
|
|
env=self.env,
|
|
lang=self.env.context.get('lang'),
|
|
keep_query=keep_query,
|
|
)
|
|
|
|
context = {'dev_mode': 'qweb' in tools.config['dev_mode']}
|
|
if 'xml' in tools.config['dev_mode']:
|
|
context['is_t_cache_disabled'] = True
|
|
elif 'disable-t-cache' in debug:
|
|
context['is_t_cache_disabled'] = True
|
|
return self.with_context(**context)
|
|
|
|
def _prepare_globals(self):
|
|
""" Prepare the global context that will sent to eval the qweb
|
|
generated code.
|
|
"""
|
|
return {
|
|
'Sized': Sized,
|
|
'Mapping': Mapping,
|
|
'Markup': Markup,
|
|
'escape': escape,
|
|
'VOID_ELEMENTS': VOID_ELEMENTS,
|
|
'QWebException': QWebException,
|
|
'Exception': Exception,
|
|
'TransactionRollbackError': TransactionRollbackError, # for SerializationFailure in assets
|
|
'ValueError': ValueError,
|
|
'UserError': UserError,
|
|
'AccessDenied': AccessDenied,
|
|
'AccessError': AccessError,
|
|
'MissingError': MissingError,
|
|
'ValidationError': ValidationError,
|
|
'warning': lambda *args: _logger.warning(*args),
|
|
**_BUILTINS,
|
|
}
|
|
|
|
# helpers for compilation
|
|
|
|
def _append_text(self, text, compile_context):
|
|
""" Add an item (converts to a string) to the list.
|
|
This will be concatenated and added during a call to the
|
|
`_flush_text` method. This makes it possible to return only one
|
|
yield containing all the parts."""
|
|
compile_context['_text_concat'].append(self._compile_to_str(text))
|
|
|
|
def _rstrip_text(self, compile_context):
|
|
""" The text to flush is right stripped, and the stripped content are
|
|
returned.
|
|
"""
|
|
text_concat = compile_context['_text_concat']
|
|
if not text_concat:
|
|
return ''
|
|
|
|
result = RSTRIP_REGEXP.search(text_concat[-1])
|
|
strip = result.group(0) if result else ''
|
|
text_concat[-1] = RSTRIP_REGEXP.sub('', text_concat[-1])
|
|
|
|
return strip
|
|
|
|
def _flush_text(self, compile_context, level, rstrip=False):
|
|
"""Concatenate all the textual chunks added by the `_append_text`
|
|
method into a single yield.
|
|
If no text to flush, return an empty list
|
|
|
|
If rstrip the text is right stripped.
|
|
|
|
@returns list(str)
|
|
"""
|
|
text_concat = compile_context['_text_concat']
|
|
if not text_concat:
|
|
return []
|
|
if rstrip:
|
|
self._rstrip_text(compile_context)
|
|
text = ''.join(text_concat)
|
|
text_concat.clear()
|
|
return [f"{' ' * level}yield {text!r}"]
|
|
|
|
def _is_static_node(self, el, compile_context):
|
|
""" Test whether the given element is purely static, i.e. (there
|
|
are no t-* attributes), does not require dynamic rendering for its
|
|
attributes.
|
|
"""
|
|
return el.tag != 't' and 'groups' not in el.attrib and not any(
|
|
att.startswith('t-') and att not in ('t-tag-open', 't-inner-content')
|
|
for att in el.attrib
|
|
)
|
|
|
|
# compile python expression and format string
|
|
|
|
def _compile_format(self, expr):
|
|
""" Parses the provided format string and compiles it to a single
|
|
expression python, uses string with format method.
|
|
Use format is faster to concat string and values.
|
|
"""
|
|
# <t t-setf-name="Hello #{world} %s !"/>
|
|
# =>
|
|
# values['name'] = 'Hello %s %%s !' % (values['world'],)
|
|
values = [
|
|
f'self._compile_to_str({self._compile_expr(m.group(1) or m.group(2))})'
|
|
for m in FORMAT_REGEX.finditer(expr)
|
|
]
|
|
code = repr(FORMAT_REGEX.sub('%s', expr.replace('%', '%%')))
|
|
if values:
|
|
code += f' % ({", ".join(values)},)'
|
|
return code
|
|
|
|
def _compile_expr_tokens(self, tokens, allowed_keys, argument_names=None, raise_on_missing=False):
|
|
""" Transform the list of token coming into a python instruction in
|
|
textual form by adding the namepaces for the dynamic values.
|
|
|
|
Example: `5 + a + b.c` to be `5 + values.get('a') + values['b'].c`
|
|
Unknown values are considered to be None, but using `values['b']`
|
|
gives a clear error message in cases where there is an attribute for
|
|
example (have a `KeyError: 'b'`, instead of `AttributeError: 'NoneType'
|
|
object has no attribute 'c'`).
|
|
|
|
@returns str
|
|
"""
|
|
# Finds and extracts the current "scope"'s "allowed values": values
|
|
# which should not be accessed through the environment's namespace:
|
|
# * the local variables of a lambda should be accessed directly e.g.
|
|
# lambda a: a + b should be compiled to lambda a: a + values['b'],
|
|
# since a is local to the lambda it has to be accessed directly
|
|
# but b needs to be accessed through the rendering environment
|
|
# * similarly for a comprehensions [a + b for a in c] should be
|
|
# compiledto [a + values.get('b') for a in values.get('c')]
|
|
# to avoid the risk of confusion between nested lambdas / comprehensions,
|
|
# this is currently performed independently at each level of brackets
|
|
# nesting (hence the function being recursive).
|
|
open_bracket_index = -1
|
|
bracket_depth = 0
|
|
|
|
argument_name = '_arg_%s__'
|
|
argument_names = argument_names or []
|
|
|
|
for index, t in enumerate(tokens):
|
|
if t.exact_type in [token.LPAR, token.LSQB, token.LBRACE]:
|
|
bracket_depth += 1
|
|
elif t.exact_type in [token.RPAR, token.RSQB, token.RBRACE]:
|
|
bracket_depth -= 1
|
|
elif bracket_depth == 0 and t.exact_type == token.NAME:
|
|
string = t.string
|
|
if string == 'lambda': # lambda => allowed values for the current bracket depth
|
|
for i in range(index + 1, len(tokens)):
|
|
t = tokens[i]
|
|
if t.exact_type == token.NAME:
|
|
argument_names.append(t.string)
|
|
elif t.exact_type == token.COMMA:
|
|
pass
|
|
elif t.exact_type == token.COLON:
|
|
break
|
|
elif t.exact_type == token.EQUAL:
|
|
raise NotImplementedError('Lambda default values are not supported')
|
|
else:
|
|
raise NotImplementedError('This lambda code style is not implemented.')
|
|
elif string == 'for': # list comprehensions => allowed values for the current bracket depth
|
|
for i in range(index + 1, len(tokens)):
|
|
t = tokens[i]
|
|
if t.exact_type == token.NAME:
|
|
if t.string == 'in':
|
|
break
|
|
argument_names.append(t.string)
|
|
elif t.exact_type in [token.COMMA, token.LPAR, token.RPAR]:
|
|
pass
|
|
else:
|
|
raise NotImplementedError('This loop code style is not implemented.')
|
|
|
|
# Use bracket to nest structures.
|
|
# Recursively processes the "sub-scopes", and replace their content with
|
|
# a compiled node. During this recursive call we add to the allowed
|
|
# values the values provided by the list comprehension, lambda, etc.,
|
|
# previously extracted.
|
|
index = 0
|
|
open_bracket_index = -1
|
|
bracket_depth = 0
|
|
|
|
while index < len(tokens):
|
|
t = tokens[index]
|
|
string = t.string
|
|
|
|
if t.exact_type in [token.LPAR, token.LSQB, token.LBRACE]:
|
|
if bracket_depth == 0:
|
|
open_bracket_index = index
|
|
bracket_depth += 1
|
|
elif t.exact_type in [token.RPAR, token.RSQB, token.RBRACE]:
|
|
bracket_depth -= 1
|
|
if bracket_depth == 0:
|
|
code = self._compile_expr_tokens(
|
|
tokens[open_bracket_index + 1:index],
|
|
list(allowed_keys),
|
|
list(argument_names),
|
|
raise_on_missing,
|
|
)
|
|
code = tokens[open_bracket_index].string + code + t.string
|
|
tokens[open_bracket_index:index + 1] = [tokenize.TokenInfo(token.QWEB, code, tokens[open_bracket_index].start, t.end, '')]
|
|
index = open_bracket_index
|
|
|
|
index += 1
|
|
|
|
# The keys will be namespaced by values if they are not allowed. In
|
|
# order to have a clear keyError message, this will be replaced by
|
|
# values['key'] for certain cases (for example if an attribute is called
|
|
# key.attrib, or an index key[0] ...)
|
|
code = []
|
|
index = 0
|
|
pos = tokens and tokens[0].start # to keep level when use expr on multi line
|
|
while index < len(tokens):
|
|
t = tokens[index]
|
|
string = t.string
|
|
|
|
if t.start[0] != pos[0]:
|
|
pos = (t.start[0], 0)
|
|
space = t.start[1] - pos[1]
|
|
if space:
|
|
code.append(' ' * space)
|
|
pos = t.start
|
|
|
|
if t.exact_type == token.NAME:
|
|
if string == 'lambda': # lambda => allowed values
|
|
code.append('lambda ')
|
|
index += 1
|
|
while index < len(tokens):
|
|
t = tokens[index]
|
|
if t.exact_type == token.NAME and t.string in argument_names:
|
|
code.append(argument_name % t.string)
|
|
if t.exact_type in [token.COMMA, token.COLON]:
|
|
code.append(t.string)
|
|
if t.exact_type == token.COLON:
|
|
break
|
|
index += 1
|
|
if t.end[0] != pos[0]:
|
|
pos = (t.end[0], 0)
|
|
else:
|
|
pos = t.end
|
|
elif string in argument_names:
|
|
code.append(argument_name % t.string)
|
|
elif string in allowed_keys:
|
|
code.append(string)
|
|
elif index + 1 < len(tokens) and tokens[index + 1].exact_type == token.EQUAL: # function kw
|
|
code.append(string)
|
|
elif index > 0 and tokens[index - 1] and tokens[index - 1].exact_type == token.DOT:
|
|
code.append(string)
|
|
elif raise_on_missing or index + 1 < len(tokens) and tokens[index + 1].exact_type in [token.DOT, token.LPAR, token.LSQB, 'qweb']:
|
|
# Should have values['product'].price to raise an error when get
|
|
# the 'product' value and not an 'NoneType' object has no
|
|
# attribute 'price' error.
|
|
code.append(f'values[{string!r}]')
|
|
else:
|
|
# not assignation allowed, only getter
|
|
code.append(f'values.get({string!r})')
|
|
elif t.type not in [tokenize.ENCODING, token.ENDMARKER, token.DEDENT]:
|
|
code.append(string)
|
|
|
|
if t.end[0] != pos[0]:
|
|
pos = (t.end[0], 0)
|
|
else:
|
|
pos = t.end
|
|
|
|
index += 1
|
|
|
|
return ''.join(code)
|
|
|
|
def _compile_expr(self, expr, raise_on_missing=False):
|
|
"""Transform string coming into a python instruction in textual form by
|
|
adding the namepaces for the dynamic values.
|
|
This method tokenize the string and call ``_compile_expr_tokens``
|
|
method.
|
|
|
|
:param expr: string: python expression
|
|
:param [raise_on_missing]: boolean:
|
|
Compile has `values['product'].price` instead of
|
|
`values.get('product').price` to raise an error when get the
|
|
'product' value and not an 'NoneType' object has no attribute
|
|
'price' error.
|
|
"""
|
|
# Parentheses are useful for compiling multi-line expressions such as
|
|
# conditions existing in some templates. (see test_compile_expr tests)
|
|
readable = io.BytesIO(f"({expr or ''})".encode('utf-8'))
|
|
try:
|
|
tokens = list(tokenize.tokenize(readable.readline))
|
|
except tokenize.TokenError:
|
|
raise ValueError(f"Can not compile expression: {expr}")
|
|
|
|
expression = self._compile_expr_tokens(tokens, ALLOWED_KEYWORD, raise_on_missing=raise_on_missing)
|
|
|
|
assert_valid_codeobj(_SAFE_QWEB_OPCODES, compile(expression, '<>', 'eval'), expr)
|
|
|
|
return f"({expression})"
|
|
|
|
def _compile_bool(self, attr, default=False):
|
|
"""Convert the statements as a boolean."""
|
|
if attr:
|
|
if attr is True:
|
|
return True
|
|
attr = attr.lower()
|
|
if attr in ('false', '0'):
|
|
return False
|
|
elif attr in ('true', '1'):
|
|
return True
|
|
return bool(default)
|
|
|
|
def _compile_to_str(self, expr):
|
|
""" Generates a text value (an instance of text_type) from an arbitrary
|
|
source.
|
|
"""
|
|
return pycompat.to_text(expr)
|
|
|
|
# order
|
|
|
|
def _directives_eval_order(self):
|
|
""" List all supported directives in the order in which they should be
|
|
evaluated on a given element. For instance, a node bearing both
|
|
``foreach`` and ``if`` should see ``foreach`` executed before ``if`` aka
|
|
.. code-block:: xml
|
|
<el t-foreach="foo" t-as="bar" t-if="bar">
|
|
should be equivalent to
|
|
.. code-block:: xml
|
|
<t t-foreach="foo" t-as="bar">
|
|
<t t-if="bar">
|
|
<el>
|
|
then this method should return ``['foreach', 'if']``.
|
|
"""
|
|
return [
|
|
'elif', # Must be the first because compiled by the previous if.
|
|
'else', # Must be the first because compiled by the previous if.
|
|
'debug',
|
|
'nocache',
|
|
'cache',
|
|
'groups',
|
|
'as', 'foreach',
|
|
'if',
|
|
'call-assets',
|
|
'lang',
|
|
'options',
|
|
'att',
|
|
'field', 'esc', 'raw', 'out',
|
|
'tag-open',
|
|
'call',
|
|
'set',
|
|
'inner-content',
|
|
'tag-close',
|
|
]
|
|
|
|
# compile
|
|
|
|
def _compile_node(self, el, compile_context, level):
|
|
""" Compile the given element into python code.
|
|
|
|
The t-* attributes (directives) will be converted to a python instruction. If there
|
|
are no t-* attributes, the element will be considered static.
|
|
|
|
Directives are compiled using the order provided by the
|
|
``_directives_eval_order`` method (an create the
|
|
``compile_context['iter_directives']`` iterator).
|
|
For compilation, the directives supported are those with a
|
|
compilation method ``_compile_directive_*``
|
|
|
|
:return: list of string
|
|
"""
|
|
# Internal directive used to skip a rendering.
|
|
if 't-qweb-skip' in el.attrib:
|
|
return []
|
|
|
|
# if tag don't have qweb attributes don't use directives
|
|
if self._is_static_node(el, compile_context):
|
|
return self._compile_static_node(el, compile_context, level)
|
|
|
|
path = compile_context['root'].getpath(el)
|
|
xml = etree.tostring(etree.Element(el.tag, el.attrib), encoding='unicode')
|
|
compile_context['_qweb_error_path_xml'] = (path, xml)
|
|
body = [indent_code(f'# element: {path!r} , {xml!r}', level)]
|
|
|
|
# create an iterator on directives to compile in order
|
|
compile_context['iter_directives'] = iter(self._directives_eval_order())
|
|
|
|
# add technical directive tag-open, tag-close, inner-content and take
|
|
# care of the namspace
|
|
if not el.nsmap:
|
|
unqualified_el_tag = el_tag = el.tag
|
|
else:
|
|
# Etree will remove the ns prefixes indirection by inlining the corresponding
|
|
# nsmap definition into the tag attribute. Restore the tag and prefix here.
|
|
# Note: we do not support namespace dynamic attributes, we need a default URI
|
|
# on the root and use attribute directive t-att="{'xmlns:example': value}".
|
|
unqualified_el_tag = etree.QName(el.tag).localname
|
|
el_tag = unqualified_el_tag
|
|
if el.prefix:
|
|
el_tag = f'{el.prefix}:{el_tag}'
|
|
|
|
if unqualified_el_tag != 't':
|
|
el.set('t-tag-open', el_tag)
|
|
if unqualified_el_tag not in VOID_ELEMENTS:
|
|
el.set('t-tag-close', el_tag)
|
|
|
|
if not ({'t-out', 't-esc', 't-raw', 't-field'} & set(el.attrib)):
|
|
el.set('t-inner-content', 'True')
|
|
|
|
return body + self._compile_directives(el, compile_context, level)
|
|
|
|
def _compile_static_node(self, el, compile_context, level):
|
|
""" Compile a purely static element into a list of string. """
|
|
if not el.nsmap:
|
|
unqualified_el_tag = el_tag = el.tag
|
|
attrib = self._post_processing_att(el.tag, el.attrib)
|
|
else:
|
|
# Etree will remove the ns prefixes indirection by inlining the corresponding
|
|
# nsmap definition into the tag attribute. Restore the tag and prefix here.
|
|
unqualified_el_tag = etree.QName(el.tag).localname
|
|
el_tag = unqualified_el_tag
|
|
if el.prefix:
|
|
el_tag = f'{el.prefix}:{el_tag}'
|
|
|
|
attrib = {}
|
|
# If `el` introduced new namespaces, write them as attribute by using the
|
|
# `attrib` dict.
|
|
for ns_prefix, ns_definition in set(el.nsmap.items()) - set(compile_context['nsmap'].items()):
|
|
if ns_prefix is None:
|
|
attrib['xmlns'] = ns_definition
|
|
else:
|
|
attrib[f'xmlns:{ns_prefix}'] = ns_definition
|
|
|
|
# Etree will also remove the ns prefixes indirection in the attributes. As we only have
|
|
# the namespace definition, we'll use an nsmap where the keys are the definitions and
|
|
# the values the prefixes in order to get back the right prefix and restore it.
|
|
ns = chain(compile_context['nsmap'].items(), el.nsmap.items())
|
|
nsprefixmap = {v: k for k, v in ns}
|
|
for key, value in el.attrib.items():
|
|
attrib_qname = etree.QName(key)
|
|
if attrib_qname.namespace:
|
|
attrib[f'{nsprefixmap[attrib_qname.namespace]}:{attrib_qname.localname}'] = value
|
|
else:
|
|
attrib[key] = value
|
|
|
|
attrib = self._post_processing_att(el.tag, attrib)
|
|
|
|
# Update the dict of inherited namespaces before continuing the recursion. Note:
|
|
# since `compile_context['nsmap']` is a dict (and therefore mutable) and we do **not**
|
|
# want changes done in deeper recursion to bevisible in earlier ones, we'll pass
|
|
# a copy before continuing the recursion and restore the original afterwards.
|
|
original_nsmap = dict(compile_context['nsmap'])
|
|
|
|
if unqualified_el_tag != 't':
|
|
attributes = ''.join(f' {name}="{escape(str(value))}"'
|
|
for name, value in attrib.items() if value or isinstance(value, str))
|
|
self._append_text(f'<{el_tag}{"".join(attributes)}', compile_context)
|
|
if unqualified_el_tag in VOID_ELEMENTS:
|
|
self._append_text('/>', compile_context)
|
|
else:
|
|
self._append_text('>', compile_context)
|
|
|
|
el.attrib.clear()
|
|
|
|
if el.nsmap:
|
|
compile_context['nsmap'].update(el.nsmap)
|
|
body = self._compile_directive(el, compile_context, 'inner-content', level)
|
|
compile_context['nsmap'] = original_nsmap
|
|
else:
|
|
body = self._compile_directive(el, compile_context, 'inner-content', level)
|
|
|
|
if unqualified_el_tag != 't':
|
|
if unqualified_el_tag not in VOID_ELEMENTS:
|
|
self._append_text(f'</{el_tag}>', compile_context)
|
|
|
|
return body
|
|
|
|
def _compile_directives(self, el, compile_context, level):
|
|
""" Compile the given element, following the directives given in the
|
|
iterator ``compile_context['iter_directives']`` create by
|
|
`_compile_node`` method.
|
|
|
|
:return: list of code lines
|
|
"""
|
|
if self._is_static_node(el, compile_context):
|
|
el.attrib.pop('t-tag-open', None)
|
|
el.attrib.pop('t-inner-content', None)
|
|
el.attrib.pop('t-tag-close', None)
|
|
return self._compile_static_node(el, compile_context, level)
|
|
|
|
code = []
|
|
|
|
# compile the directives still present on the element
|
|
for directive in compile_context['iter_directives']:
|
|
if ('t-' + directive) in el.attrib:
|
|
code.extend(self._compile_directive(el, compile_context, directive, level))
|
|
elif directive == 'groups':
|
|
if directive in el.attrib:
|
|
code.extend(self._compile_directive(el, compile_context, directive, level))
|
|
elif directive == 'att':
|
|
code.extend(self._compile_directive(el, compile_context, directive, level))
|
|
elif directive == 'options':
|
|
if any(name.startswith('t-options-') for name in el.attrib):
|
|
code.extend(self._compile_directive(el, compile_context, directive, level))
|
|
elif directive == 'nocache':
|
|
if any(name.startswith('t-nocache-') for name in el.attrib):
|
|
code.extend(self._compile_directive(el, compile_context, directive, level))
|
|
|
|
# compile unordered directives still present on the element
|
|
for att in el.attrib:
|
|
if att not in SPECIAL_DIRECTIVES and att.startswith('t-') and getattr(self, f"_compile_directive_{att[2:].replace('-', '_')}", None):
|
|
code.extend(self._compile_directive(el, compile_context, directive, level))
|
|
|
|
remaining = set(el.attrib) - SPECIAL_DIRECTIVES
|
|
if remaining:
|
|
_logger.warning('Unknown directives or unused attributes: %s in %s', remaining, compile_context['template'])
|
|
|
|
return code
|
|
|
|
@QwebTracker.wrap_compile_directive
|
|
def _compile_directive(self, el, compile_context, directive, level):
|
|
compile_handler = getattr(self, f"_compile_directive_{directive.replace('-', '_')}", None)
|
|
return compile_handler(el, compile_context, level)
|
|
|
|
# compile directives
|
|
|
|
def _compile_directive_debug(self, el, compile_context, level):
|
|
"""Compile `t-debug` expressions into a python code as a list of
|
|
strings.
|
|
|
|
The code will contains the call to the debugger chosen from the valid
|
|
list.
|
|
"""
|
|
debugger = el.attrib.pop('t-debug')
|
|
code = []
|
|
if compile_context.get('dev_mode'):
|
|
code.append(indent_code(f"self._debug_trace({debugger!r}, values)", level))
|
|
else:
|
|
_logger.warning("@t-debug in template is only available in qweb dev mode")
|
|
return code
|
|
|
|
def _compile_directive_options(self, el, compile_context, level):
|
|
"""
|
|
compile t-options and add to the dict the t-options-xxx. Will create
|
|
the dictionary ``values['__qweb_options__']`` in compiled code.
|
|
"""
|
|
code = []
|
|
dict_options = []
|
|
for key in list(el.attrib):
|
|
if key.startswith('t-options-'):
|
|
value = el.attrib.pop(key)
|
|
option_name = key[10:]
|
|
dict_options.append(f'{option_name!r}:{self._compile_expr(value)}')
|
|
|
|
t_options = el.attrib.pop('t-options', None)
|
|
if t_options and dict_options:
|
|
code.append(indent_code(f"values['__qweb_options__'] = {{**{self._compile_expr(t_options)}, {', '.join(dict_options)}}}", level))
|
|
elif dict_options:
|
|
code.append(indent_code(f"values['__qweb_options__'] = {{{', '.join(dict_options)}}}", level))
|
|
elif t_options:
|
|
code.append(indent_code(f"values['__qweb_options__'] = {self._compile_expr(t_options)}", level))
|
|
else:
|
|
code.append(indent_code("values['__qweb_options__'] = {}", level))
|
|
|
|
el.set('t-consumed-options', str(bool(code)))
|
|
|
|
return code
|
|
|
|
def _compile_directive_consumed_options(self, el, compile_context, level):
|
|
raise SyntaxError('the t-options must be on the same tag as a directive that consumes it (for example: t-out, t-field, t-call)')
|
|
|
|
def _compile_directive_att(self, el, compile_context, level):
|
|
""" Compile the attributes of the given elements.
|
|
|
|
The compiled function will create the ``values['__qweb_attrs__']``
|
|
dictionary. Then the dictionary will be output.
|
|
|
|
|
|
The new namespaces of the current element.
|
|
|
|
The static attributes (not prefixed by ``t-``) are add to the
|
|
dictionary in first.
|
|
|
|
The dynamic attributes values will be add after. The dynamic
|
|
attributes has different origins.
|
|
- value from key equal to ``t-att``: python dictionary expression;
|
|
- value from keys that start with ``t-att-``: python expression;
|
|
- value from keys that start with ``t-attf-``: format string
|
|
expression.
|
|
"""
|
|
code = [indent_code("attrs = values['__qweb_attrs__'] = {}", level)]
|
|
|
|
# Compile the introduced new namespaces of the given element.
|
|
#
|
|
# Add the found new attributes into the `attrs` dictionary like
|
|
# the static attributes.
|
|
if el.nsmap:
|
|
for ns_prefix, ns_definition in set(el.nsmap.items()) - set(compile_context['nsmap'].items()):
|
|
key = 'xmlns'
|
|
if ns_prefix is not None:
|
|
key = f'xmlns:{ns_prefix}'
|
|
code.append(indent_code(f'attrs[{key!r}] = {ns_definition!r}', level))
|
|
|
|
# Compile the static attributes of the given element.
|
|
#
|
|
# Etree will also remove the ns prefixes indirection in the
|
|
# attributes. As we only have the namespace definition, we'll use
|
|
# an nsmap where the keys are the definitions and the values the
|
|
# prefixes in order to get back the right prefix and restore it.
|
|
if any(not name.startswith('t-') for name in el.attrib):
|
|
nsprefixmap = {v: k for k, v in chain(compile_context['nsmap'].items(), el.nsmap.items())}
|
|
for key in list(el.attrib):
|
|
if not key.startswith('t-'):
|
|
value = el.attrib.pop(key)
|
|
attrib_qname = etree.QName(key)
|
|
if attrib_qname.namespace:
|
|
key = f'{nsprefixmap[attrib_qname.namespace]}:{attrib_qname.localname}'
|
|
code.append(indent_code(f'attrs[{key!r}] = {value!r}', level))
|
|
|
|
# Compile the dynamic attributes of the given element. All
|
|
# attributes will be add to the ``attrs`` dictionary in the
|
|
# compiled function.
|
|
for key in list(el.attrib):
|
|
if key.startswith('t-attf-'):
|
|
value = el.attrib.pop(key)
|
|
code.append(indent_code(f"attrs[{key[7:]!r}] = {self._compile_format(value)}", level))
|
|
elif key.startswith('t-att-'):
|
|
value = el.attrib.pop(key)
|
|
code.append(indent_code(f"attrs[{key[6:]!r}] = {self._compile_expr(value)}", level))
|
|
elif key == 't-att':
|
|
value = el.attrib.pop(key)
|
|
code.append(indent_code(f"""
|
|
atts_value = {self._compile_expr(value)}
|
|
if isinstance(atts_value, dict):
|
|
attrs.update(atts_value)
|
|
elif isinstance(atts_value, (list, tuple)) and not isinstance(atts_value[0], (list, tuple)):
|
|
attrs.update([atts_value])
|
|
elif isinstance(atts_value, (list, tuple)):
|
|
attrs.update(dict(atts_value))
|
|
""", level))
|
|
|
|
return code
|
|
|
|
def _compile_directive_tag_open(self, el, compile_context, level):
|
|
""" Compile the opening tag with attributes of the given element into
|
|
a list of python code line.
|
|
|
|
The compiled function will fill the ``attrs`` dictionary. Then the
|
|
``attrs`` dictionary will be output and reset the value of ``attrs``.
|
|
|
|
The static attributes (not prefixed by ``t-``) are add to the
|
|
``attrs`` dictionary in first.
|
|
|
|
The dynamic attributes values will be add after. The dynamic
|
|
attributes has different origins.
|
|
- value from key equal to ``t-att``: python dictionary expression;
|
|
- value from keys that start with ``t-att-``: python expression;
|
|
- value from keys that start with ``t-attf-``: format string
|
|
expression.
|
|
"""
|
|
|
|
el_tag = el.attrib.pop('t-tag-open', None)
|
|
if not el_tag:
|
|
return []
|
|
|
|
# open the open tag
|
|
self._append_text(f"<{el_tag}", compile_context)
|
|
|
|
code = self._flush_text(compile_context, level)
|
|
|
|
# Generates the part of the code that prost process and output the
|
|
# attributes from ``attrs`` dictionary. Consumes `attrs` dictionary
|
|
# and reset it.
|
|
#
|
|
# Use str(value) to change Markup into str and escape it, then use str
|
|
# to avoid the escaping of the other html content.
|
|
code.append(indent_code(f"""
|
|
attrs = values.pop('__qweb_attrs__', None)
|
|
if attrs:
|
|
tagName = {el.tag!r}
|
|
attrs = self._post_processing_att(tagName, attrs)
|
|
for name, value in attrs.items():
|
|
if value or isinstance(value, str):
|
|
yield f' {{escape(str(name))}}="{{escape(str(value))}}"'
|
|
""", level))
|
|
|
|
# close the open tag
|
|
if 't-tag-close' in el.attrib:
|
|
self._append_text('>', compile_context)
|
|
else:
|
|
self._append_text('/>', compile_context)
|
|
|
|
return code
|
|
|
|
def _compile_directive_tag_close(self, el, compile_context, level):
|
|
""" Compile the closing tag of the given element into string.
|
|
Returns an empty list because it's use only `_append_text`.
|
|
"""
|
|
el_tag = el.attrib.pop("t-tag-close", None)
|
|
if el_tag:
|
|
self._append_text(f'</{el_tag}>', compile_context)
|
|
return []
|
|
|
|
def _compile_directive_set(self, el, compile_context, level):
|
|
"""Compile `t-set` expressions into a python code as a list of
|
|
strings.
|
|
|
|
There are 3 kinds of `t-set`:
|
|
* `t-value` containing python code;
|
|
* `t-valuef` containing strings to format;
|
|
* whose value is the content of the tag (being Markup safe).
|
|
|
|
The code will contain the assignment of the dynamically generated value.
|
|
"""
|
|
|
|
code = self._flush_text(compile_context, level, rstrip=el.tag.lower() == 't')
|
|
|
|
if 't-set' in el.attrib:
|
|
varname = el.attrib.pop('t-set')
|
|
if varname == "":
|
|
raise KeyError('t-set')
|
|
if varname != T_CALL_SLOT and varname[0] != '{' and not VARNAME_REGEXP.match(varname):
|
|
raise ValueError('The varname can only contain alphanumeric characters and underscores.')
|
|
|
|
if 't-value' in el.attrib or 't-valuef' in el.attrib or varname[0] == '{':
|
|
el.attrib.pop('t-inner-content') # The content is considered empty.
|
|
if varname == T_CALL_SLOT:
|
|
raise SyntaxError('t-set="0" should not be set from t-value or t-valuef')
|
|
|
|
if 't-value' in el.attrib:
|
|
expr = el.attrib.pop('t-value') or 'None'
|
|
code.append(indent_code(f"values[{varname!r}] = {self._compile_expr(expr)}", level))
|
|
elif 't-valuef' in el.attrib:
|
|
exprf = el.attrib.pop('t-valuef')
|
|
code.append(indent_code(f"values[{varname!r}] = {self._compile_format(exprf)}", level))
|
|
elif varname[0] == '{':
|
|
code.append(indent_code(f"values.update({self._compile_expr(varname)})", level))
|
|
else:
|
|
# set the content as value
|
|
content = (
|
|
self._compile_directive(el, compile_context, 'inner-content', 1) +
|
|
self._flush_text(compile_context, 1))
|
|
if content:
|
|
def_name = compile_context['make_name']('t_set')
|
|
compile_context['template_functions'][def_name] = [f"def {def_name}(self, values):"] + content
|
|
code.append(indent_code(f"""
|
|
t_set = []
|
|
for item in {def_name}(self, values):
|
|
if isinstance(item, str):
|
|
t_set.append(item)
|
|
else:
|
|
ref, function_name, cached_values = item
|
|
t_nocache_function = values['__qweb_loaded_values'].get(function_name)
|
|
if not t_nocache_function:
|
|
t_call_template_functions, def_name = self._compile(ref)
|
|
t_nocache_function = t_call_template_functions[function_name]
|
|
|
|
nocache_values = values['__qweb_root_values'].copy()
|
|
nocache_values.update(cached_values)
|
|
t_set.extend(t_nocache_function(self, nocache_values))
|
|
""", level))
|
|
expr = "Markup(''.join(t_set))"
|
|
else:
|
|
expr = "''"
|
|
code.append(indent_code(f"values[{varname!r}] = {expr}", level))
|
|
|
|
return code
|
|
|
|
def _compile_directive_value(self, el, compile_context, level):
|
|
"""Compile `t-value` expressions into a python code as a list of strings.
|
|
|
|
This method only check if this attributes is on the same node of a
|
|
`t-set` attribute.
|
|
"""
|
|
raise SyntaxError("t-value must be on the same node of t-set")
|
|
|
|
def _compile_directive_valuef(self, el, compile_context, level):
|
|
"""Compile `t-valuef` expressions into a python code as a list of strings.
|
|
|
|
This method only check if this attributes is on the same node of a
|
|
`t-set` attribute.
|
|
"""
|
|
raise SyntaxError("t-valuef must be on the same node of t-set")
|
|
|
|
def _compile_directive_inner_content(self, el, compile_context, level):
|
|
"""Compiles the content of the element (is the technical `t-inner-content`
|
|
directive created by QWeb) into a python code as a list of
|
|
strings.
|
|
|
|
The code will contains the text content of the node or the compliled
|
|
code from the recursive call of ``_compile_node``.
|
|
"""
|
|
el.attrib.pop('t-inner-content', None)
|
|
|
|
if el.nsmap:
|
|
# Update the dict of inherited namespaces before continuing the recursion. Note:
|
|
# since `compile_context['nsmap']` is a dict (and therefore mutable) and we do **not**
|
|
# want changes done in deeper recursion to bevisible in earlier ones, we'll pass
|
|
# a copy before continuing the recursion and restore the original afterwards.
|
|
compile_context = dict(compile_context, nsmap=el.nsmap)
|
|
|
|
if el.text is not None:
|
|
self._append_text(el.text, compile_context)
|
|
body = []
|
|
for item in el:
|
|
if isinstance(item, etree._Comment):
|
|
if compile_context.get('preserve_comments'):
|
|
self._append_text(f"<!--{item.text}-->", compile_context)
|
|
elif isinstance(item, etree._ProcessingInstruction):
|
|
if compile_context.get('preserve_comments'):
|
|
self._append_text(f"<?{item.target} {item.text}?>", compile_context)
|
|
else:
|
|
body.extend(self._compile_node(item, compile_context, level))
|
|
# comments can also contains tail text
|
|
if item.tail is not None:
|
|
self._append_text(item.tail, compile_context)
|
|
return body
|
|
|
|
def _compile_directive_if(self, el, compile_context, level):
|
|
"""Compile `t-if` expressions into a python code as a list of strings.
|
|
|
|
The code will contain the condition `if`, `else` and `elif` part that
|
|
wrap the rest of the compiled code of this element.
|
|
"""
|
|
expr = el.attrib.pop('t-if', el.attrib.pop('t-elif', None))
|
|
|
|
assert not expr.isspace(), 't-if or t-elif expression should not be empty.'
|
|
|
|
strip = self._rstrip_text(compile_context) # the withspaces is visible only when display a content
|
|
if el.tag.lower() == 't' and el.text and LSTRIP_REGEXP.search(el.text):
|
|
strip = '' # remove technical spaces
|
|
code = self._flush_text(compile_context, level)
|
|
|
|
code.append(indent_code(f"if {self._compile_expr(expr)}:", level))
|
|
body = []
|
|
if strip:
|
|
self._append_text(strip, compile_context)
|
|
body.extend(
|
|
self._compile_directives(el, compile_context, level + 1) +
|
|
self._flush_text(compile_context, level + 1, rstrip=True))
|
|
code.extend(body or [indent_code('pass', level + 1)])
|
|
|
|
# Look for the else or elif conditions
|
|
next_el = el.getnext()
|
|
comments_to_remove = []
|
|
while isinstance(next_el, etree._Comment):
|
|
comments_to_remove.append(next_el)
|
|
next_el = next_el.getnext()
|
|
|
|
# If there is a t-else directive, the comment nodes are deleted
|
|
# and the t-else or t-elif is validated.
|
|
if next_el is not None and {'t-else', 't-elif'} & set(next_el.attrib):
|
|
# Insert a flag to allow t-else or t-elif rendering.
|
|
next_el.attrib['t-else-valid'] = 'True'
|
|
|
|
# remove comment node
|
|
parent = el.getparent()
|
|
for comment in comments_to_remove:
|
|
parent.remove(comment)
|
|
if el.tail and not el.tail.isspace():
|
|
raise SyntaxError("Unexpected non-whitespace characters between t-if and t-else directives")
|
|
el.tail = None
|
|
|
|
# You have to render the `t-else` and `t-elif` here in order
|
|
# to be able to put the log. Otherwise, the parent's
|
|
# `t-inner-content`` directive will render the different
|
|
# nodes without taking indentation into account such as:
|
|
# if (if_expression):
|
|
# content_if
|
|
# log ['last_path_node'] = path
|
|
# else:
|
|
# content_else
|
|
|
|
code.append(indent_code("else:", level))
|
|
body = []
|
|
if strip:
|
|
self._append_text(strip, compile_context)
|
|
body.extend(
|
|
self._compile_node(next_el, compile_context, level + 1)+
|
|
self._flush_text(compile_context, level + 1, rstrip=True))
|
|
code.extend(body or [indent_code('pass', level + 1)])
|
|
|
|
# Insert a flag to avoid the t-else or t-elif rendering when
|
|
# the parent t-inner-content dirrective compile his
|
|
# children.
|
|
next_el.attrib['t-qweb-skip'] = 'True'
|
|
|
|
return code
|
|
|
|
def _compile_directive_elif(self, el, compile_context, level):
|
|
"""Compile `t-elif` expressions into a python code as a list of
|
|
strings. This method is linked with the `t-if` directive.
|
|
|
|
Check if this directive is valide, the t-qweb-skip flag and call
|
|
`t-if` directive
|
|
"""
|
|
if not el.attrib.pop('t-else-valid', None):
|
|
raise SyntaxError("t-elif directive must be preceded by t-if or t-elif directive")
|
|
|
|
return self._compile_directive_if(el, compile_context, level)
|
|
|
|
def _compile_directive_else(self, el, compile_context, level):
|
|
"""Compile `t-else` expressions into a python code as a list of strings.
|
|
This method is linked with the `t-if` directive.
|
|
|
|
Check if this directive is valide and add the t-qweb-skip flag.
|
|
"""
|
|
if not el.attrib.pop('t-else-valid', None):
|
|
raise SyntaxError("t-elif directive must be preceded by t-if or t-elif directive")
|
|
el.attrib.pop('t-else')
|
|
return []
|
|
|
|
def _compile_directive_groups(self, el, compile_context, level):
|
|
"""Compile `t-groups` expressions into a python code as a list of
|
|
strings.
|
|
|
|
The code will contain the condition `if self.user_has_groups(groups)`
|
|
part that wrap the rest of the compiled code of this element.
|
|
"""
|
|
groups = el.attrib.pop('t-groups', el.attrib.pop('groups', None))
|
|
|
|
strip = self._rstrip_text(compile_context)
|
|
code = self._flush_text(compile_context, level)
|
|
code.append(indent_code(f"if self.user_has_groups({groups!r}):", level))
|
|
if strip and el.tag.lower() != 't':
|
|
self._append_text(strip, compile_context)
|
|
code.extend([
|
|
*self._compile_directives(el, compile_context, level + 1),
|
|
*self._flush_text(compile_context, level + 1, rstrip=True),
|
|
] or [indent_code('pass', level + 1)])
|
|
return code
|
|
|
|
def _compile_directive_foreach(self, el, compile_context, level):
|
|
"""Compile `t-foreach` expressions into a python code as a list of
|
|
strings.
|
|
|
|
`t-as` is used to define the key name.
|
|
`t-foreach` compiled value can be an iterable, an dictionary or a
|
|
number.
|
|
|
|
The code will contain loop `for` that wrap the rest of the compiled
|
|
code of this element.
|
|
Some key into values dictionary are create automatically:
|
|
*_size, *_index, *_value, *_first, *_last, *_odd, *_even, *_parity
|
|
"""
|
|
expr_foreach = el.attrib.pop('t-foreach')
|
|
expr_as = el.attrib.pop('t-as')
|
|
|
|
if not expr_as:
|
|
raise KeyError('t-as')
|
|
|
|
if not VARNAME_REGEXP.match(expr_as):
|
|
raise ValueError(f'The varname {expr_as!r} can only contain alphanumeric characters and underscores.')
|
|
|
|
if el.tag.lower() == 't':
|
|
self._rstrip_text(compile_context)
|
|
|
|
code = self._flush_text(compile_context, level)
|
|
|
|
content_foreach = (
|
|
self._compile_directives(el, compile_context, level + 1) +
|
|
self._flush_text(compile_context, level + 1, rstrip=True))
|
|
|
|
t_foreach = compile_context['make_name']('t_foreach')
|
|
size = compile_context['make_name']('size')
|
|
has_value = compile_context['make_name']('has_value')
|
|
|
|
if expr_foreach.isdigit():
|
|
code.append(indent_code(f"""
|
|
values[{expr_as + '_size'!r}] = {size} = {int(expr_foreach)}
|
|
{t_foreach} = range({size})
|
|
{has_value} = False
|
|
""", level))
|
|
else:
|
|
code.append(indent_code(f"""
|
|
{t_foreach} = {self._compile_expr(expr_foreach)} or []
|
|
if isinstance({t_foreach}, Sized):
|
|
values[{expr_as + '_size'!r}] = {size} = len({t_foreach})
|
|
elif ({t_foreach}).__class__ == int:
|
|
values[{expr_as + '_size'!r}] = {size} = {t_foreach}
|
|
{t_foreach} = range({size})
|
|
else:
|
|
{size} = None
|
|
{has_value} = False
|
|
if isinstance({t_foreach}, Mapping):
|
|
{t_foreach} = {t_foreach}.items()
|
|
{has_value} = True
|
|
""", level))
|
|
|
|
code.append(indent_code(f"""
|
|
for index, item in enumerate({t_foreach}):
|
|
values[{expr_as + '_index'!r}] = index
|
|
if {has_value}:
|
|
values[{expr_as!r}], values[{expr_as + '_value'!r}] = item
|
|
else:
|
|
values[{expr_as!r}] = values[{expr_as + '_value'!r}] = item
|
|
values[{expr_as + '_first'!r}] = values[{expr_as + '_index'!r}] == 0
|
|
if {size} is not None:
|
|
values[{expr_as + '_last'!r}] = index + 1 == {size}
|
|
values[{expr_as + '_odd'!r}] = index % 2
|
|
values[{expr_as + '_even'!r}] = not values[{expr_as + '_odd'!r}]
|
|
values[{expr_as + '_parity'!r}] = 'odd' if values[{expr_as + '_odd'!r}] else 'even'
|
|
""", level))
|
|
|
|
code.extend(content_foreach or indent_code('continue', level + 1))
|
|
|
|
return code
|
|
|
|
def _compile_directive_as(self, el, compile_context, level):
|
|
"""Compile `t-as` expressions into a python code as a list of strings.
|
|
|
|
This method only check if this attributes is on the same node of a
|
|
`t-foreach` attribute.
|
|
"""
|
|
if 't-foreach' not in el.attrib:
|
|
raise SyntaxError("t-as must be on the same node of t-foreach")
|
|
return []
|
|
|
|
def _compile_directive_out(self, el, compile_context, level):
|
|
"""Compile `t-out` expressions into a python code as a list of
|
|
strings.
|
|
|
|
The code will contain evalution and rendering of the compiled value. If
|
|
the compiled value is None or False, the tag is not added to the render
|
|
(Except if the widget forces rendering or there is default content).
|
|
(eg: `<t t-out="my_value">Default content if falsy</t>`)
|
|
|
|
The output can have some rendering option with `t-options-widget` or
|
|
`t-options={'widget': ...}. At rendering time, The compiled code will
|
|
call ``_get_widget`` method or ``_get_field`` method for `t-field`.
|
|
|
|
A `t-field` will necessarily be linked to the value of a record field
|
|
(eg: `<span t-field="record.field_name"/>`), a t-out` can be applied
|
|
to any value (eg: `<span t-out="10" t-options-widget="'float'"/>`).
|
|
"""
|
|
ttype = 't-out'
|
|
expr = el.attrib.pop('t-out', None)
|
|
if expr is None:
|
|
ttype = 't-field'
|
|
expr = el.attrib.pop('t-field', None)
|
|
if expr is None:
|
|
# deprecated use.
|
|
ttype = 't-esc'
|
|
expr = el.attrib.pop('t-esc', None)
|
|
if expr is None:
|
|
ttype = 't-raw'
|
|
expr = el.attrib.pop('t-raw')
|
|
|
|
code = self._flush_text(compile_context, level)
|
|
|
|
code_options = el.attrib.pop('t-consumed-options', 'None')
|
|
tag_open = (
|
|
self._compile_directive(el, compile_context, 'tag-open', level + 1) +
|
|
self._flush_text(compile_context, level + 1))
|
|
tag_close = (
|
|
self._compile_directive(el, compile_context, 'tag-close', level + 1) +
|
|
self._flush_text(compile_context, level + 1))
|
|
default_body = (
|
|
self._compile_directive(el, compile_context, 'inner-content', level + 1) +
|
|
self._flush_text(compile_context, level + 1))
|
|
|
|
# The generated code will set the values of the content, attrs (used to
|
|
# output attributes) and the force_display (if the widget or field
|
|
# mark force_display as True, the tag will be inserted in the output
|
|
# even the value of content is None and without default value)
|
|
|
|
if expr == T_CALL_SLOT and code_options != 'True':
|
|
code.append(indent_code("if True:", level))
|
|
code.extend(tag_open)
|
|
code.append(indent_code(f"yield from values.get({T_CALL_SLOT}, [])", level + 1))
|
|
code.extend(tag_close)
|
|
return code
|
|
elif ttype == 't-field':
|
|
record, field_name = expr.rsplit('.', 1)
|
|
code.append(indent_code(f"""
|
|
field_attrs, content, force_display = self._get_field({self._compile_expr(record, raise_on_missing=True)}, {field_name!r}, {expr!r}, {el.tag!r}, values.pop('__qweb_options__', {{}}), values)
|
|
if values.get('__qweb_attrs__') is None:
|
|
values['__qweb_attrs__'] = field_attrs
|
|
else:
|
|
values['__qweb_attrs__'].update(field_attrs)
|
|
if content is not None and content is not False:
|
|
content = self._compile_to_str(content)
|
|
""", level))
|
|
force_display_dependent = True
|
|
else:
|
|
if expr == T_CALL_SLOT:
|
|
code.append(indent_code(f"content = Markup(''.join(values.get({T_CALL_SLOT}, [])))", level))
|
|
else:
|
|
code.append(indent_code(f"content = {self._compile_expr(expr)}", level))
|
|
|
|
if code_options == 'True':
|
|
code.append(indent_code(f"""
|
|
widget_attrs, content, force_display = self._get_widget(content, {expr!r}, {el.tag!r}, values.pop('__qweb_options__', {{}}), values)
|
|
if values.get('__qweb_attrs__') is None:
|
|
values['__qweb_attrs__'] = widget_attrs
|
|
else:
|
|
values['__qweb_attrs__'].update(widget_attrs)
|
|
content = self._compile_to_str(content)
|
|
""", level))
|
|
force_display_dependent = True
|
|
else:
|
|
force_display_dependent = False
|
|
|
|
if ttype == 't-raw':
|
|
# deprecated use.
|
|
code.append(indent_code("""
|
|
if content is not None and content is not False:
|
|
content = Markup(content)
|
|
""", level))
|
|
|
|
# The generated code will create the output tag with all attribute.
|
|
# If the value is not falsy or if there is default content or if it's
|
|
# in force_display mode, the tag is add into the output.
|
|
|
|
el.attrib.pop('t-tag', None) # code generating the output is done here
|
|
|
|
# generate code to display the tag if the value is not Falsy
|
|
|
|
code.append(indent_code("if content is not None and content is not False:", level))
|
|
code.extend(tag_open)
|
|
# Use str to avoid the escaping of the other html content because the
|
|
# yield generator MarkupSafe values will be join into an string in
|
|
# `_render`.
|
|
code.append(indent_code("yield str(escape(content))", level + 1))
|
|
code.extend(tag_close)
|
|
|
|
# generate code to display the tag with default content if the value is
|
|
# Falsy
|
|
|
|
if default_body or compile_context['_text_concat']:
|
|
_text_concat = list(compile_context['_text_concat'])
|
|
compile_context['_text_concat'].clear()
|
|
code.append(indent_code("else:", level))
|
|
code.extend(tag_open)
|
|
code.extend(default_body)
|
|
compile_context['_text_concat'].extend(_text_concat)
|
|
code.extend(tag_close)
|
|
elif force_display_dependent:
|
|
|
|
# generate code to display the tag if it's the force_diplay mode.
|
|
|
|
if tag_open + tag_close:
|
|
code.append(indent_code("elif force_display:", level))
|
|
code.extend(tag_open + tag_close)
|
|
|
|
code.append(indent_code("""else: values.pop('__qweb_attrs__', None)""", level))
|
|
|
|
return code
|
|
|
|
def _compile_directive_esc(self, el, compile_context, level):
|
|
# deprecated use.
|
|
if compile_context.get('dev_mode'):
|
|
_logger.warning(
|
|
"Found deprecated directive @t-esc=%r in template %r. Replace by @t-out",
|
|
el.get('t-esc'),
|
|
compile_context.get('ref', '<unknown>'),
|
|
)
|
|
return self._compile_directive_out(el, compile_context, level)
|
|
|
|
def _compile_directive_raw(self, el, compile_context, level):
|
|
# deprecated use.
|
|
_logger.warning(
|
|
"Found deprecated directive @t-raw=%r in template %r. Replace by "
|
|
"@t-out, and explicitely wrap content in `Markup` if "
|
|
"necessary (which likely is not the case)",
|
|
el.get('t-raw'),
|
|
compile_context.get('ref', '<unknown>'),
|
|
)
|
|
return self._compile_directive_out(el, compile_context, level)
|
|
|
|
def _compile_directive_field(self, el, compile_context, level):
|
|
"""Compile `t-field` expressions into a python code as a list of
|
|
strings.
|
|
|
|
The compiled code will call ``_get_field`` method at rendering time
|
|
using the type of value supplied by the field. This behavior can be
|
|
changed with `t-options-widget` or `t-options={'widget': ...}.
|
|
|
|
The code will contain evalution and rendering of the compiled value
|
|
value from the record field. If the compiled value is None or False,
|
|
the tag is not added to the render
|
|
(Except if the widget forces rendering or there is default content.).
|
|
"""
|
|
tagName = el.tag
|
|
assert tagName not in ("table", "tbody", "thead", "tfoot", "tr", "td",
|
|
"li", "ul", "ol", "dl", "dt", "dd"),\
|
|
"QWeb widgets do not work correctly on %r elements" % tagName
|
|
assert tagName != 't',\
|
|
"t-field can not be used on a t element, provide an actual HTML node"
|
|
assert "." in el.get('t-field'),\
|
|
"t-field must have at least a dot like 'record.field_name'"
|
|
|
|
return self._compile_directive_out(el, compile_context, level)
|
|
|
|
def _compile_directive_call(self, el, compile_context, level):
|
|
"""Compile `t-call` expressions into a python code as a list of
|
|
strings.
|
|
|
|
`t-call` allow formating string dynamic at rendering time.
|
|
Can use `t-options` used to call and render the sub-template at
|
|
rendering time.
|
|
The sub-template is called with a copy of the rendering values
|
|
dictionary. The dictionary contains the key 0 coming from the
|
|
compilation of the contents of this element
|
|
|
|
The code will contain the call of the template and a function from the
|
|
compilation of the content of this element.
|
|
"""
|
|
expr = el.attrib.pop('t-call')
|
|
|
|
if el.attrib.get('t-call-options'): # retro-compatibility
|
|
el.attrib.set('t-options', el.attrib.pop('t-call-options'))
|
|
|
|
nsmap = compile_context.get('nsmap')
|
|
|
|
code = self._flush_text(compile_context, level, rstrip=el.tag.lower() == 't')
|
|
|
|
# options
|
|
el.attrib.pop('t-consumed-options', None)
|
|
code.append(indent_code("t_call_options = values.pop('__qweb_options__', {})", level))
|
|
if nsmap:
|
|
# update this dict with the current nsmap so that the callee know
|
|
# if he outputting the xmlns attributes is relevenat or not
|
|
nsmap = []
|
|
for key, value in compile_context['nsmap'].items():
|
|
if isinstance(key, str):
|
|
nsmap.append(f'{key!r}:{value!r}')
|
|
else:
|
|
nsmap.append(f'None:{value!r}')
|
|
code.append(indent_code(f"t_call_options.update(nsmap={{{', '.join(nsmap)}}})", level))
|
|
|
|
# values (t-out="0" from content and variables from t-set)
|
|
def_name = compile_context['make_name']('t_call')
|
|
|
|
# values from content (t-out="0" and t-set inside the content)
|
|
code_content = [f"def {def_name}(self, values):"]
|
|
code_content.extend(self._compile_directive(el, compile_context, 'inner-content', 1))
|
|
self._append_text('', compile_context) # To ensure the template function is a generator and doesn't become a regular function
|
|
code_content.extend(self._flush_text(compile_context, 1, rstrip=True))
|
|
compile_context['template_functions'][def_name] = code_content
|
|
|
|
code.append(indent_code(f"""
|
|
t_call_values = values.copy()
|
|
t_call_values[{T_CALL_SLOT}] = list({def_name}(self, t_call_values))
|
|
""", level))
|
|
|
|
template = self._compile_format(expr)
|
|
|
|
# call
|
|
code.append(indent_code(f"""
|
|
irQweb = self.with_context(**t_call_options)
|
|
template = {template}
|
|
if template.isnumeric():
|
|
template = int(template)
|
|
t_call_template_functions, def_name = irQweb._compile(template)
|
|
render_template = t_call_template_functions[def_name]
|
|
yield from render_template(irQweb, t_call_values)
|
|
""", level))
|
|
|
|
return code
|
|
|
|
def _compile_directive_lang(self, el, compile_context, level):
|
|
if 't-call' not in el.attrib:
|
|
raise SyntaxError("t-lang is an alias of t-options-lang but only available on the same node of t-call")
|
|
el.attrib['t-options-lang'] = el.attrib.pop('t-lang')
|
|
return self._compile_node(el, compile_context, level)
|
|
|
|
def _compile_directive_call_assets(self, el, compile_context, level):
|
|
""" This special 't-call-assets' tag can be used in order to aggregate/minify javascript and css assets"""
|
|
if len(el) > 0:
|
|
raise SyntaxError("t-call-assets cannot contain children nodes")
|
|
|
|
code = self._flush_text(compile_context, level)
|
|
xmlid = el.attrib.pop('t-call-assets')
|
|
css = self._compile_bool(el.attrib.pop('t-css', True))
|
|
js = self._compile_bool(el.attrib.pop('t-js', True))
|
|
async_load = self._compile_bool(el.attrib.pop('async_load', False))
|
|
defer_load = self._compile_bool(el.attrib.pop('defer_load', False))
|
|
lazy_load = self._compile_bool(el.attrib.pop('lazy_load', False))
|
|
media = el.attrib.pop('media', False)
|
|
code.append(indent_code(f"""
|
|
t_call_assets_nodes = self._get_asset_nodes(
|
|
{xmlid!r},
|
|
css={css},
|
|
js={js},
|
|
debug=values.get("debug"),
|
|
async_load={async_load},
|
|
defer_load={defer_load},
|
|
lazy_load={lazy_load},
|
|
media={media!r},
|
|
)
|
|
""".strip(), level))
|
|
|
|
code.append(indent_code("""
|
|
for index, (tagName, asset_attrs, content) in enumerate(t_call_assets_nodes):
|
|
if index:
|
|
yield '\\n '
|
|
yield '<'
|
|
yield tagName
|
|
|
|
attrs = self._post_processing_att(tagName, asset_attrs)
|
|
for name, value in attrs.items():
|
|
if value or isinstance(value, str):
|
|
yield f' {escape(str(name))}="{escape(str(value))}"'
|
|
|
|
if not content and tagName in VOID_ELEMENTS:
|
|
yield '/>'
|
|
else:
|
|
yield '>'
|
|
if content:
|
|
yield content
|
|
yield '</'
|
|
yield tagName
|
|
yield '>'
|
|
""", level))
|
|
|
|
return code
|
|
|
|
def _compile_directive_cache(self, el, compile_context, level):
|
|
"""Compile the `t-cache` tuple expression into a key cache.
|
|
|
|
The `t-cache` directive allows you to keep the rendered result
|
|
of a template part. The supplied key must be a tuple. This tuple
|
|
can contain recordset in this case the zone will be invalidated
|
|
each time the write_date of these records changes.
|
|
The values are scoped into the `t-cache` and are not available
|
|
outside.
|
|
see: `t-nocache`
|
|
"""
|
|
expr = el.attrib.pop('t-cache')
|
|
code = self._flush_text(compile_context, level)
|
|
|
|
def_name = compile_context['make_name']('t_cache')
|
|
|
|
# Generate the content function
|
|
def_code = [indent_code(f"""def {def_name}(self, values):""", 0)]
|
|
def_content = self._compile_directives(el, compile_context, 1)
|
|
if def_content and not compile_context['_text_concat']:
|
|
self._append_text('', compile_context) # To ensure the template function is a generator and doesn't become a regular function
|
|
def_code.extend(def_content)
|
|
def_code.extend(self._flush_text(compile_context, 1))
|
|
compile_context['template_functions'][def_name] = def_code
|
|
|
|
# Get the dynamic key for the cache and load the content.
|
|
# The t-nocache yield a tuple (ref, function name) instead of a
|
|
# When reading tuple coming from t-nocache, we check if the
|
|
# method is already known otherwise the corresponding template
|
|
# and its functions are loaded.
|
|
code.append(indent_code(f"""
|
|
template_cache_key = {self._compile_expr(expr)} if not self.env.context.get('is_t_cache_disabled') else None
|
|
cache_key = self._get_cache_key(template_cache_key) if template_cache_key else None
|
|
uniq_cache_key = cache_key and ({str(self.env.context['__qweb_base_key_cache'])!r}, '{def_name}_cache', cache_key)
|
|
loaded_values = values['__qweb_loaded_values']
|
|
def {def_name}_cache():
|
|
content = []
|
|
text = []
|
|
for item in {def_name}(self, {{**values, '__qweb_in_cache': True}}):
|
|
if isinstance(item, str):
|
|
text.append(item)
|
|
else:
|
|
content.append(''.join(text))
|
|
content.append(item)
|
|
text = []
|
|
if text:
|
|
content.append(''.join(text))
|
|
return content
|
|
cache_content = self._load_values(uniq_cache_key, {def_name}_cache, loaded_values)
|
|
if values.get('__qweb_in_cache'):
|
|
yield from cache_content
|
|
else:
|
|
for item in cache_content:
|
|
if isinstance(item, str):
|
|
yield item
|
|
else:
|
|
ref, function_name, cached_values = item
|
|
t_nocache_function = loaded_values.get(function_name)
|
|
if not t_nocache_function:
|
|
t_call_template_functions, def_name = self._compile(ref)
|
|
t_nocache_function = t_call_template_functions[function_name]
|
|
|
|
nocache_values = values['__qweb_root_values'].copy()
|
|
nocache_values.update(cached_values)
|
|
yield ''.join(t_nocache_function(self, nocache_values))
|
|
""", level))
|
|
|
|
return code
|
|
|
|
def _compile_directive_nocache(self, el, compile_context, level):
|
|
"""
|
|
The `t-nocache` directive makes it possible to force rendering
|
|
of a part even if it is in a `t-cache`. The values available in
|
|
the `t-nocache` are the one provided when calling the template
|
|
(and therefore ignores any t-set that could have been done).
|
|
|
|
The `t-nocache-*` are the values whose result of the
|
|
expression will be cached and added to the root's values when
|
|
rendering the no cache part. Only primitive types can be cached.
|
|
|
|
see: `t-cache`
|
|
"""
|
|
if 't-nocache' not in el.attrib:
|
|
raise SyntaxError("t-nocache-* must be on the same node as t-nocache")
|
|
|
|
el.attrib.pop('t-nocache')
|
|
code = self._flush_text(compile_context, level)
|
|
|
|
# t-nocache-* will generate the values to put in cache
|
|
# must cosume this attributes before generate the cached content.
|
|
code_cache_values = []
|
|
for key in list(el.attrib):
|
|
if key.startswith('t-nocache-'):
|
|
expr = el.attrib.pop(key)
|
|
varname = key[10:]
|
|
if not VARNAME_REGEXP.match(varname):
|
|
raise ValueError(f'The varname {varname!r} can only contain alphanumeric characters and underscores.')
|
|
code_cache_values.append(indent_code(f"""
|
|
cached_value = {self._compile_expr(expr)}
|
|
if cached_value is not None and not isinstance(cached_value, (str, int, float, bool)):
|
|
raise ValueError(f'''The value type of {key!r} cannot be cached: {{cached_value!r}}''')
|
|
cached_values[{varname!r}] = cached_value
|
|
""", level + 1))
|
|
|
|
# generate the cached content method
|
|
def_name = compile_context['make_name']('t_nocache')
|
|
def_code = [f"def {def_name}(self, values):"]
|
|
def_code.append(indent_code("try:", 1))
|
|
def_content = self._compile_directives(el, compile_context, 2)
|
|
if def_content and not compile_context['_text_concat']:
|
|
self._append_text('', compile_context) # To ensure the template function is a generator and doesn't become a regular function
|
|
def_code.extend(def_content)
|
|
def_code.extend(self._flush_text(compile_context, 2))
|
|
def_code.append(indent_code(f"""
|
|
except QWebException:
|
|
raise
|
|
except Exception as e:
|
|
raise QWebException("Error while render the template",
|
|
self, template, ref={compile_context['ref']!r}, code=code) from e
|
|
""", 1))
|
|
compile_context['template_functions'][def_name] = def_code
|
|
|
|
# if the nocache is inside a cache return a tuple with the method name and the cached values
|
|
code.append(indent_code("""
|
|
if values.get('__qweb_in_cache'):
|
|
cached_values = {}
|
|
""", level))
|
|
code.extend(code_cache_values)
|
|
code.append(indent_code(f"yield ({compile_context['template']!r}, {def_name!r}, cached_values)", level+1))
|
|
# else render the content
|
|
code.append(indent_code(f"""
|
|
else:
|
|
yield from {def_name}(self, values)
|
|
""", level))
|
|
|
|
return code
|
|
|
|
# methods called by the compiled function at rendering time.
|
|
|
|
def _debug_trace(self, debugger, values):
|
|
"""Method called at running time to load debugger."""
|
|
if debugger in SUPPORTED_DEBUGGER:
|
|
__import__(debugger).set_trace()
|
|
else:
|
|
raise ValueError(f"unsupported t-debug value: {debugger}")
|
|
|
|
def _post_processing_att(self, tagName, atts):
|
|
""" Method called at compile time for the static node and called at
|
|
runing time for the dynamic attributes.
|
|
|
|
This method may be overwrited to filter or modify the attributes
|
|
(during compilation for static node or after they compilation in
|
|
the case of dynamic elements).
|
|
|
|
@returns dict
|
|
"""
|
|
return atts
|
|
|
|
def _get_field(self, record, field_name, expression, tagName, field_options, values):
|
|
"""Method called at compile time to return the field value.
|
|
|
|
:returns: tuple:
|
|
* dict: attributes
|
|
* string or None: content
|
|
* boolean: force_display display the tag if the content and default_content are None
|
|
"""
|
|
field = record._fields[field_name]
|
|
|
|
# adds generic field options
|
|
field_options['tagName'] = tagName
|
|
field_options['expression'] = expression
|
|
field_options['type'] = field_options.get('widget', field.type)
|
|
inherit_branding = (
|
|
self.env.context['inherit_branding']
|
|
if 'inherit_branding' in self.env.context
|
|
else self.env.context.get('inherit_branding_auto') and record.check_access_rights('write', False))
|
|
field_options['inherit_branding'] = inherit_branding
|
|
translate = self.env.context.get('edit_translations') and values.get('translatable') and field.translate
|
|
field_options['translate'] = translate
|
|
|
|
# field converter
|
|
model = 'ir.qweb.field.' + field_options['type']
|
|
converter = self.env[model] if model in self.env else self.env['ir.qweb.field']
|
|
|
|
# get content (the return values from fields are considered to be markup safe)
|
|
content = converter.record_to_html(record, field_name, field_options)
|
|
attributes = converter.attributes(record, field_name, field_options, values)
|
|
|
|
return (attributes, content, inherit_branding or translate)
|
|
|
|
def _get_widget(self, value, expression, tagName, field_options, values):
|
|
"""Method called at compile time to return the widget value.
|
|
|
|
:returns: tuple:
|
|
* dict: attributes
|
|
* string or None: content
|
|
* boolean: force_display display the tag if the content and default_content are None
|
|
"""
|
|
field_options['type'] = field_options['widget']
|
|
field_options['tagName'] = tagName
|
|
field_options['expression'] = expression
|
|
inherit_branding = self.env.context.get('inherit_branding')
|
|
field_options['inherit_branding'] = inherit_branding
|
|
|
|
# field converter
|
|
model = 'ir.qweb.field.' + field_options['type']
|
|
converter = self.env[model] if model in self.env else self.env['ir.qweb.field']
|
|
|
|
# get content (the return values from widget are considered to be markup safe)
|
|
content = converter.value_to_html(value, field_options)
|
|
attributes = {}
|
|
attributes['data-oe-type'] = field_options['type']
|
|
attributes['data-oe-expression'] = field_options['expression']
|
|
|
|
return (attributes, content, inherit_branding)
|
|
|
|
def _get_asset_nodes(self, bundle, css=True, js=True, debug=False, async_load=False, defer_load=False, lazy_load=False, media=None):
|
|
"""Generates asset nodes.
|
|
If debug=assets, the assets will be regenerated when a file which composes them has been modified.
|
|
Else, the assets will be generated only once and then stored in cache.
|
|
"""
|
|
if debug and 'assets' in debug:
|
|
return self._generate_asset_nodes(bundle, css, js, debug, async_load, defer_load, lazy_load, media)
|
|
else:
|
|
return self._generate_asset_nodes_cache(bundle, css, js, debug, async_load, defer_load, lazy_load, media)
|
|
|
|
# qweb cache feature
|
|
|
|
def _get_cache_key(self, cache_key):
|
|
"""
|
|
Convert the template cache key item into a hashable key.
|
|
:param cache_key: tuple
|
|
:returns: tuple of hashable items
|
|
"""
|
|
if not isinstance(cache_key, (tuple, list)):
|
|
cache_key = (cache_key,)
|
|
keys = []
|
|
for item in cache_key:
|
|
try:
|
|
# use try catch instead of isinstance to detect lazy values
|
|
keys.append(item._name)
|
|
keys.append(tuple(item.ids))
|
|
dates = item.mapped('write_date')
|
|
if dates:
|
|
keys.append(max(dates).timestamp())
|
|
except AttributeError:
|
|
keys.append(repr(item))
|
|
return tuple(keys)
|
|
|
|
def _load_values(self, cache_key, get_value, loaded_values=None):
|
|
""" generate value from the function if the result is not cached. """
|
|
if not cache_key:
|
|
return get_value()
|
|
|
|
value = loaded_values and loaded_values.get(cache_key)
|
|
if not value:
|
|
value = self._get_cached_values(cache_key, get_value)
|
|
if loaded_values is not None:
|
|
loaded_values[cache_key] = value
|
|
return value
|
|
|
|
# The cache does not need to be invalidated if the 'base_key_cache'
|
|
# in '_compile' method contains the write_date of all inherited views.
|
|
@tools.conditional(
|
|
'xml' not in tools.config['dev_mode'],
|
|
tools.ormcache('cache_key'),
|
|
)
|
|
def _get_cached_values(self, cache_key, get_value):
|
|
""" generate value from the function if the result is not cached. """
|
|
return get_value()
|
|
|
|
# other methods used for the asset bundles
|
|
@tools.conditional(
|
|
# in non-xml-debug mode we want assets to be cached forever, and the admin can force a cache clear
|
|
# by restarting the server after updating the source code (or using the "Clear server cache" in debug tools)
|
|
'xml' not in tools.config['dev_mode'],
|
|
tools.ormcache('bundle', 'css', 'js', 'debug', 'async_load', 'defer_load', 'lazy_load', 'media', 'tuple(self.env.context.get(k) for k in self._get_template_cache_keys())'),
|
|
)
|
|
def _generate_asset_nodes_cache(self, bundle, css=True, js=True, debug=False, async_load=False, defer_load=False, lazy_load=False, media=None):
|
|
return self._generate_asset_nodes(bundle, css, js, debug, async_load, defer_load, lazy_load, media)
|
|
|
|
@tools.ormcache('bundle', 'defer_load', 'lazy_load', 'media', 'tuple(self.env.context.get(k) for k in self._get_template_cache_keys())')
|
|
def _get_asset_content(self, bundle, defer_load=False, lazy_load=False, media=None):
|
|
asset_paths = self.env['ir.asset']._get_asset_paths(bundle=bundle, css=True, js=True)
|
|
files = []
|
|
remains = []
|
|
for path, full_path, _bundle, last_modified in asset_paths:
|
|
ext = path.rpartition('.')[2]
|
|
is_js = ext in SCRIPT_EXTENSIONS
|
|
is_xml = ext in TEMPLATE_EXTENSIONS
|
|
is_css = ext in STYLE_EXTENSIONS
|
|
if not is_js and not is_xml and not is_css:
|
|
continue
|
|
|
|
mimetype = None
|
|
if is_js:
|
|
mimetype = 'text/javascript'
|
|
elif is_css:
|
|
mimetype = f'text/{ext}'
|
|
elif is_xml:
|
|
mimetype = 'text/xml'
|
|
|
|
if full_path is not EXTERNAL_ASSET:
|
|
files.append({
|
|
'atype': mimetype,
|
|
'url': path,
|
|
'filename': full_path,
|
|
'content': '',
|
|
'media': media,
|
|
'last_modified': last_modified,
|
|
})
|
|
else:
|
|
if is_js:
|
|
tag = 'script'
|
|
attributes = {
|
|
"type": mimetype,
|
|
}
|
|
attributes["data-src" if lazy_load else "src"] = path
|
|
if defer_load:
|
|
# lazy_load will add defer in JS otherwise this is not
|
|
# W3C valid (defer is probably not needed there anyways)
|
|
attributes["defer"] = "defer"
|
|
elif is_css:
|
|
tag = 'link'
|
|
attributes = {
|
|
"type": mimetype,
|
|
"rel": "stylesheet",
|
|
"href": path,
|
|
'media': media,
|
|
}
|
|
elif is_xml:
|
|
tag = 'script'
|
|
attributes = {
|
|
"type": mimetype,
|
|
"async": "async",
|
|
"rel": "prefetch",
|
|
"data-src": path,
|
|
}
|
|
remains.append((tag, attributes, None))
|
|
|
|
return (files, remains)
|
|
|
|
def _get_asset_bundle(self, bundle_name, files, env=None, css=True, js=True, debug=False):
|
|
return AssetsBundle(bundle_name, files, env=env, css=css, js=js, debug=debug)
|
|
|
|
def _generate_asset_nodes(self, bundle, css=True, js=True, debug=False, async_load=False, defer_load=False, lazy_load=False, media=None):
|
|
files, remains = self._get_asset_content(bundle, defer_load=defer_load, lazy_load=lazy_load, media=css and media or None)
|
|
asset = self._get_asset_bundle(bundle, files, env=self.env, css=css, js=js, debug=debug)
|
|
remains = [node for node in remains if (css and node[0] == 'link') or (js and node[0] == 'script')]
|
|
return remains + asset.to_node(css=css, js=js, async_load=async_load, defer_load=defer_load, lazy_load=lazy_load)
|
|
|
|
def _get_asset_link_urls(self, bundle, debug=False):
|
|
asset_nodes = self._get_asset_nodes(bundle, js=False, debug=debug)
|
|
return [node[1]['href'] for node in asset_nodes if node[0] == 'link']
|
|
|
|
def _pregenerate_assets_bundles(self):
|
|
"""
|
|
Pregenerates all assets that may be used in web pages to speedup first loading.
|
|
This may is mainly usefull for tests.
|
|
|
|
The current version is looking for all t-call-assets in view to generate the minimal
|
|
set of bundles to generate.
|
|
|
|
Current version only generate assets without extra, not taking care of rtl.
|
|
"""
|
|
_logger.runbot('Pregenerating assets bundles')
|
|
|
|
views = self.env['ir.ui.view'].search([('type', '=', 'qweb'), ('arch_db', 'like', 't-call-assets')])
|
|
js_bundles = set()
|
|
css_bundles = set()
|
|
for view in views:
|
|
for call_asset in etree.fromstring(view.arch_db).xpath("//*[@t-call-assets]"):
|
|
asset = call_asset.get('t-call-assets')
|
|
js = str2bool(call_asset.get('t-js', 'True'))
|
|
css = str2bool(call_asset.get('t-css', 'True'))
|
|
if js:
|
|
js_bundles.add(asset)
|
|
if css:
|
|
css_bundles.add(asset)
|
|
nodes = []
|
|
start = time.time()
|
|
for bundle in sorted(js_bundles):
|
|
nodes += self._generate_asset_nodes(bundle, css=False, js=True)
|
|
_logger.info('JS Assets bundles generated in %s seconds', time.time()-start)
|
|
start = time.time()
|
|
for bundle in sorted(css_bundles):
|
|
nodes += self._generate_asset_nodes(bundle, css=True, js=False)
|
|
_logger.info('CSS Assets bundles generated in %s seconds', time.time()-start)
|
|
return nodes
|
|
|
|
|
|
def render(template_name, values, load, **options):
|
|
""" Rendering of a qweb template without database and outside the registry.
|
|
(Widget, field, or asset rendering is not implemented.)
|
|
:param (string|int) template_name: template identifier
|
|
:param dict values: template values to be used for rendering
|
|
:param def load: function like `load(template_name)` which returns an etree
|
|
from the given template name (from initial rendering or template
|
|
`t-call`).
|
|
:param options: used to compile the template
|
|
:returns: bytes marked as markup-safe (decode to :class:`markupsafe.Markup`
|
|
instead of `str`)
|
|
:rtype: MarkupSafe
|
|
"""
|
|
class MockPool:
|
|
db_name = None
|
|
_Registry__cache = {}
|
|
|
|
class MockIrQWeb(IrQWeb):
|
|
_register = False # not visible in real registry
|
|
|
|
pool = MockPool()
|
|
|
|
def _load(self, ref):
|
|
"""
|
|
Load the template referenced by ``ref``.
|
|
|
|
:returns: The loaded template (as string or etree) and its
|
|
identifier
|
|
:rtype: Tuple[Union[etree, str], Optional[str, int]]
|
|
"""
|
|
return self.env.context['load'](ref)
|
|
|
|
def _prepare_environment(self, values):
|
|
values['true'] = True
|
|
values['false'] = False
|
|
return self.with_context(is_t_cache_disabled=True, __qweb_loaded_values={})
|
|
|
|
def _get_field(self, *args):
|
|
raise NotImplementedError("Fields are not allowed in this rendering mode. Please use \"env['ir.qweb']._render\" method")
|
|
|
|
def _get_widget(self, *args):
|
|
raise NotImplementedError("Widgets are not allowed in this rendering mode. Please use \"env['ir.qweb']._render\" method")
|
|
|
|
def _get_asset_nodes(self, *args):
|
|
raise NotImplementedError("Assets are not allowed in this rendering mode. Please use \"env['ir.qweb']._render\" method")
|
|
|
|
class MockEnv(dict):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.context = {}
|
|
|
|
def __call__(self, cr=None, user=None, context=None, su=None):
|
|
""" Return an mocked environment based and update the sent context.
|
|
Allow to use `ir_qweb.with_context` with sand boxed qweb.
|
|
"""
|
|
env = MockEnv()
|
|
env.context.update(self.context if context is None else context)
|
|
return env
|
|
|
|
renderer = MockIrQWeb(MockEnv(), tuple(), tuple())
|
|
return renderer._render(template_name, values, load=load, minimal_qcontext=True, **options)
|