5 #from openerp.tools.safe_eval import safe_eval as eval
7 import xml # FIXME use lxml
10 _logger = logging.getLogger(__name__)
12 class QWebEval(object):
13 def __init__(self, data):
16 def __getitem__(self, expr):
18 return self.data[expr]
21 r = eval(expr, self.data)
24 except AttributeError:
27 _logger.exception('invalid expression: %r', expr)
29 self.data.pop('__builtins__', None)
32 def eval_object(self, expr):
35 def eval_str(self, expr):
37 return self.data.get(0, '')
38 if isinstance(self[expr], unicode):
39 return self[expr].encode("utf8")
40 return str(self[expr])
42 def eval_format(self, expr):
44 return str(expr % self)
46 return "qweb: format error '%s' " % expr
47 # if isinstance(r,unicode):
48 # return r.encode("utf8")
50 def eval_bool(self, expr):
51 if self.eval_object(expr):
56 class QWebXml(object):
57 """QWeb Xml templating engine
59 The templating engine use a very simple syntax, "magic" xml attributes, to
60 produce any kind of texutal output (even non-xml).
63 the template engine core implements the basic magic attributes:
65 t-att t-raw t-esc t-if t-foreach t-set t-call t-trim
68 - loader: function that return a template
72 def __init__(self, loader=None):
74 self.node = xml.dom.Node
77 self._void_elements = set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
78 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])
79 prefix = 'render_tag_'
80 for i in [j for j in dir(self) if j.startswith(prefix)]:
81 name = i[len(prefix):].replace('_', '-')
82 self._render_tag[name] = getattr(self.__class__, i)
85 prefix = 'render_att_'
86 for i in [j for j in dir(self) if j.startswith(prefix)]:
87 name = i[len(prefix):].replace('_', '-')
88 self._render_att[name] = getattr(self.__class__, i)
90 def register_tag(self, tag, func):
91 self._render_tag[tag] = func
93 def add_template(self, x):
94 if hasattr(x, 'documentElement'):
96 elif x.startswith("<?xml"):
97 dom = xml.dom.minidom.parseString(x)
99 dom = xml.dom.minidom.parse(x)
100 for n in dom.documentElement.childNodes:
101 if n.nodeName == "t":
102 self._t[str(n.getAttribute("t-name"))] = n
104 def get_template(self, name):
108 xml = self.loader(name)
109 self.add_template(xml)
112 raise KeyError('qweb: template "%s" not found' % name)
114 def eval_object(self, expr, v):
115 return QWebEval(v).eval_object(expr)
117 def eval_str(self, expr, v):
118 return QWebEval(v).eval_str(expr)
120 def eval_format(self, expr, v):
121 return QWebEval(v).eval_format(expr)
123 def eval_bool(self, expr, v):
124 return QWebEval(v).eval_bool(expr)
126 def render(self, tname, v=None, out=None):
129 return self.render_node(self.get_template(tname), v)
131 def render_node(self, e, v):
133 if e.nodeType == self.node.TEXT_NODE or e.nodeType == self.node.CDATA_SECTION_NODE:
134 r = e.data.encode("utf8")
135 elif e.nodeType == self.node.ELEMENT_NODE:
139 for (an, av) in e.attributes.items():
141 if isinstance(av, types.UnicodeType):
142 av = av.encode("utf8")
144 av = av.nodeValue.encode("utf8")
145 if an.startswith("t-"):
146 for i in self._render_att:
147 if an[2:].startswith(i):
148 g_att += self._render_att[i](self, e, an, av, v)
151 if an[2:] in self._render_tag:
155 g_att += ' %s="%s"' % (an, cgi.escape(av, 1))
157 if t_render in self._render_tag:
158 r = self._render_tag[t_render](self, e, t_att, g_att, v)
160 r = self.render_element(e, t_att, g_att, v)
163 def render_element(self, e, t_att, g_att, v, inner=None):
165 # t_att: t-* attributes
166 # g_att: generated attributes
168 # inner: optional innerXml
173 for n in e.childNodes:
174 g_inner.append(self.render_node(n, v))
175 name = str(e.nodeName)
176 inner = "".join(g_inner)
177 trim = t_att.get("trim", 0)
181 inner = inner.lstrip()
182 elif trim == 'right':
183 inner = inner.rstrip()
185 inner = inner.strip()
188 elif len(inner) or name not in self._void_elements:
189 return "<%s%s>%s</%s>" % (name, g_att, inner, name)
191 return "<%s%s/>" % (name, g_att)
194 def render_att_att(self, e, an, av, v):
195 if an.startswith("t-attf-"):
196 att, val = an[7:], self.eval_format(av, v)
197 elif an.startswith("t-att-"):
198 att, val = an[6:], self.eval_str(av, v)
200 att, val = self.eval_object(av, v)
201 return ' %s="%s"' % (att, cgi.escape(val, 1))
204 def render_tag_raw(self, e, t_att, g_att, v):
205 inner = self.eval_str(t_att["raw"], v)
206 return self.render_element(e, t_att, g_att, v, inner)
208 def render_tag_rawf(self, e, t_att, g_att, v):
209 inner = self.eval_format(t_att["rawf"], v)
210 return self.render_element(e, t_att, g_att, v, inner)
212 def render_tag_esc(self, e, t_att, g_att, v):
213 inner = cgi.escape(self.eval_str(t_att["esc"], v))
214 return self.render_element(e, t_att, g_att, v, inner)
216 def render_tag_escf(self, e, t_att, g_att, v):
217 inner = cgi.escape(self.eval_format(t_att["escf"], v))
218 return self.render_element(e, t_att, g_att, v, inner)
220 def render_tag_foreach(self, e, t_att, g_att, v):
221 expr = t_att["foreach"]
222 enum = self.eval_object(expr, v)
224 var = t_att.get('as', expr).replace('.', '_')
227 if isinstance(enum, types.ListType):
229 elif isinstance(enum, types.TupleType):
231 elif hasattr(enum, 'count'):
233 d["%s_size" % var] = size
234 d["%s_all" % var] = enum
238 d["%s_value" % var] = i
239 d["%s_index" % var] = index
240 d["%s_first" % var] = index == 0
241 d["%s_even" % var] = index % 2
242 d["%s_odd" % var] = (index + 1) % 2
243 d["%s_last" % var] = index + 1 == size
245 d["%s_parity" % var] = 'odd'
247 d["%s_parity" % var] = 'even'
248 if isinstance(i, types.DictType):
252 ru.append(self.render_element(e, t_att, g_att, d))
256 return "qweb: t-foreach %s not found." % expr
258 def render_tag_if(self, e, t_att, g_att, v):
259 if self.eval_bool(t_att["if"], v):
260 return self.render_element(e, t_att, g_att, v)
264 def render_tag_call(self, e, t_att, g_att, v):
265 if "import" in t_att:
269 d[0] = self.render_element(e, t_att, g_att, d)
270 return self.render(t_att["call"], d)
272 def render_tag_set(self, e, t_att, g_att, v):
274 v[t_att["set"]] = self.eval_object(t_att["value"], v)
276 v[t_att["set"]] = self.render_element(e, t_att, g_att, v)
279 def render_tag_field(self, e, t_att, g_att, v):
280 """ eg: <span t-record="browse_record(res.partner, 1)" t-field="phone">+1 555 555 8069</span>"""
282 record, field = t_att["field"].rsplit('.', 1)
283 record = self.eval_object(record, v)
286 field_type = record._model._all_columns.get(field).column._type
288 if field_type == 'many2one':
289 field_data = record.read([field])[0].get(field)
290 inner = field_data and field_data[1] or ""
292 inner = getattr(record, field) or ""
293 if isinstance(inner, types.UnicodeType):
294 inner = inner.encode("utf8")
295 if field_type != 'html':
296 cgi.escape(str(inner))
299 ' %s="%s"' % (name, cgi.escape(str(value), True))
301 ('data-oe-model', record._model._name),
302 ('data-oe-id', str(record.id)),
303 ('data-oe-field', field),
304 ('data-oe-type', field_type),
307 except AttributeError:
308 _logger.warning("t-field no field %s for model %s", field, record._model._name)
310 return self.render_element(e, t_att, g_att, v, str(inner))