mirror of
https://github.com/bringout/oca-edi.git
synced 2026-04-23 08:32:00 +02:00
231 lines
7 KiB
Python
231 lines
7 KiB
Python
"""
|
|
Extracted from QWeb Framework v0.7
|
|
|
|
https://github.com/antonylesuisse/qweb/blob/master/qweb_python/qweb/qweb.py
|
|
|
|
License
|
|
-------
|
|
Public domain.
|
|
"""
|
|
|
|
import logging
|
|
import xml.dom
|
|
import xml.dom.minidom
|
|
|
|
_logger = logging.getLogger("miniqweb")
|
|
|
|
|
|
# ----------------------------------------------------------
|
|
# Qweb Xml t-raw t-if t-foreach t-set t-trim
|
|
# ----------------------------------------------------------
|
|
class QWebEval:
|
|
def __init__(self, data):
|
|
self.data = data
|
|
|
|
def __getitem__(self, expr):
|
|
if expr in self.data:
|
|
return self.data[expr]
|
|
r = None
|
|
try:
|
|
r = eval(expr, self.data) # pylint: disable=W0123
|
|
except NameError:
|
|
_logger.debug("qweb: name error")
|
|
except AttributeError:
|
|
_logger.debug("qweb: attribute error")
|
|
except Exception as e:
|
|
_logger.debug("qweb: expression error '%s' " % expr, e)
|
|
if "__builtins__" in self.data:
|
|
del self.data["__builtins__"]
|
|
return r
|
|
|
|
def eval_object(self, expr):
|
|
return self[expr]
|
|
|
|
def eval_str(self, expr):
|
|
if expr == "0":
|
|
return self.data[0]
|
|
return str(self[expr])
|
|
|
|
def eval_format(self, expr):
|
|
try:
|
|
return str(expr % self)
|
|
except Exception:
|
|
return "qweb: format error '%s' " % expr
|
|
|
|
def eval_bool(self, expr):
|
|
if self.eval_object(expr):
|
|
return 1
|
|
else:
|
|
return 0
|
|
|
|
|
|
class QWebXml:
|
|
"""QWeb Xml templating engine
|
|
|
|
The templating engine use a very simple syntax, "magic" xml attributes, to
|
|
produce any kind of texutal output (even non-xml).
|
|
|
|
QWebXml:
|
|
the template engine core implements the basic magic attributes:
|
|
|
|
t-att t-raw t-if t-foreach t-set t-trim
|
|
|
|
"""
|
|
|
|
def __init__(self, x=None):
|
|
self.node = xml.dom.Node
|
|
self._t = {}
|
|
self._render_tag = {}
|
|
prefix = "render_tag_"
|
|
for i in [j for j in dir(self) if j.startswith(prefix)]:
|
|
name = i[len(prefix) :].replace("_", "-")
|
|
self._render_tag[name] = getattr(self.__class__, i)
|
|
|
|
self._render_att = {}
|
|
prefix = "render_att_"
|
|
for i in [j for j in dir(self) if j.startswith(prefix)]:
|
|
name = i[len(prefix) :].replace("_", "-")
|
|
self._render_att[name] = getattr(self.__class__, i)
|
|
|
|
if x is not None:
|
|
self.add_template(x)
|
|
|
|
def register_tag(self, tag, func):
|
|
self._render_tag[tag] = func
|
|
|
|
def add_template(self, x):
|
|
dom = xml.dom.minidom.parseString(x)
|
|
self._t = dom
|
|
|
|
def eval_object(self, expr, v):
|
|
return QWebEval(v).eval_object(expr)
|
|
|
|
def eval_str(self, expr, v):
|
|
return QWebEval(v).eval_str(expr)
|
|
|
|
def eval_format(self, expr, v):
|
|
return QWebEval(v).eval_format(expr)
|
|
|
|
def eval_bool(self, expr, v):
|
|
return QWebEval(v).eval_bool(expr)
|
|
|
|
def render(self, v, out=None):
|
|
return self.render_node(self._t.childNodes[0], v)
|
|
|
|
def render_node(self, e, v):
|
|
r = ""
|
|
if (
|
|
e.nodeType == self.node.TEXT_NODE
|
|
or e.nodeType == self.node.CDATA_SECTION_NODE
|
|
):
|
|
r = e.data
|
|
elif e.nodeType == self.node.ELEMENT_NODE:
|
|
pre = ""
|
|
g_att = ""
|
|
t_render = None
|
|
t_att = {}
|
|
for an, av in e.attributes.items():
|
|
if an.startswith("t-"):
|
|
for i in self._render_att:
|
|
if an[2:].startswith(i):
|
|
g_att += self._render_att[i](self, e, an, av, v)
|
|
break
|
|
else:
|
|
if an[2:] in self._render_tag:
|
|
t_render = an[2:]
|
|
t_att[an[2:]] = av
|
|
else:
|
|
g_att += ' {}="{}"'.format(an, av)
|
|
if t_render:
|
|
if t_render in self._render_tag:
|
|
r = self._render_tag[t_render](self, e, t_att, g_att, v)
|
|
else:
|
|
r = self.render_element(e, g_att, v, pre, t_att.get("trim", 0))
|
|
return r
|
|
|
|
def render_element(self, e, g_att, v, pre="", trim=0):
|
|
g_inner = []
|
|
for n in e.childNodes:
|
|
g_inner.append(self.render_node(n, v))
|
|
name = str(e.nodeName)
|
|
inner = "".join(g_inner)
|
|
if trim == 0:
|
|
pass
|
|
elif trim == "left":
|
|
inner = inner.lstrip()
|
|
elif trim == "right":
|
|
inner = inner.rstrip()
|
|
elif trim == "both":
|
|
inner = inner.strip()
|
|
if name == "t":
|
|
return inner
|
|
elif len(inner):
|
|
return "<{}{}>{}{}</{}>".format(name, g_att, pre, inner, name)
|
|
else:
|
|
return "<{}{}/>".format(name, g_att)
|
|
|
|
# Attributes
|
|
def render_att_att(self, e, an, av, v):
|
|
if an.startswith("t-attf-"):
|
|
att, val = an[7:], self.eval_format(av, v)
|
|
elif an.startswith("t-att-"):
|
|
att, val = (an[6:], self.eval_str(av, v))
|
|
else:
|
|
att, val = self.eval_object(av, v)
|
|
return ' {}="{}"'.format(att, val)
|
|
|
|
# Tags
|
|
def render_tag_raw(self, e, t_att, g_att, v):
|
|
return self.eval_str(t_att["raw"], v)
|
|
|
|
def render_tag_rawf(self, e, t_att, g_att, v):
|
|
return self.eval_format(t_att["rawf"], v)
|
|
|
|
def render_tag_foreach(self, e, t_att, g_att, v):
|
|
expr = t_att["foreach"]
|
|
enum = self.eval_object(expr, v)
|
|
if enum is not None:
|
|
var = t_att.get("as", expr).replace(".", "_")
|
|
d = v.copy()
|
|
size = -1
|
|
if isinstance(enum, (list, tuple)):
|
|
size = len(enum)
|
|
elif hasattr(enum, "count"):
|
|
size = enum.count()
|
|
d["%s_size" % var] = size
|
|
d["%s_all" % var] = enum
|
|
index = 0
|
|
ru = []
|
|
for i in enum:
|
|
d["%s_value" % var] = i
|
|
d["%s_index" % var] = index
|
|
d["%s_first" % var] = index == 0
|
|
d["%s_even" % var] = index % 2
|
|
d["%s_odd" % var] = (index + 1) % 2
|
|
d["%s_last" % var] = index + 1 == size
|
|
if index % 2:
|
|
d["%s_parity" % var] = "odd"
|
|
else:
|
|
d["%s_parity" % var] = "even"
|
|
if isinstance(i, dict):
|
|
d.update(i)
|
|
else:
|
|
d[var] = i
|
|
ru.append(self.render_element(e, g_att, d))
|
|
index += 1
|
|
return "".join(ru)
|
|
else:
|
|
return "qweb: t-foreach %s not found." % expr
|
|
|
|
def render_tag_if(self, e, t_att, g_att, v):
|
|
if self.eval_bool(t_att["if"], v):
|
|
return self.render_element(e, g_att, v)
|
|
else:
|
|
return ""
|
|
|
|
def render_tag_set(self, e, t_att, g_att, v):
|
|
if "eval" in t_att:
|
|
v[t_att["set"]] = self.eval_object(t_att["eval"], v)
|
|
else:
|
|
v[t_att["set"]] = self.render_element(e, g_att, v)
|
|
return ""
|