[IMP] pynazilint
[odoo/odoo.git] / openerp / tools / qweb.py
1 import cgi
2 import logging
3 import types
4
5 #from openerp.tools.safe_eval import safe_eval as eval
6
7 import xml   # FIXME use lxml
8 import xml.dom.minidom
9
10 _logger = logging.getLogger(__name__)
11
12 class QWebEval(object):
13     def __init__(self, data):
14         self.data = data
15
16     def __getitem__(self, expr):
17         if expr in self.data:
18             return self.data[expr]
19         r = ''
20         try:
21             r = eval(expr, self.data)
22         except NameError:
23             pass
24         except AttributeError:
25             pass
26         except Exception:
27             _logger.exception('invalid expression: %r', expr)
28
29         self.data.pop('__builtins__', None)
30         return r
31
32     def eval_object(self, expr):
33         return self[expr]
34
35     def eval_str(self, expr):
36         if expr == "0":
37             return self.data.get(0, '')
38         if isinstance(self[expr], unicode):
39             return self[expr].encode("utf8")
40         return str(self[expr])
41
42     def eval_format(self, expr):
43         try:
44             return str(expr % self)
45         except:
46             return "qweb: format error '%s' " % expr
47 #       if isinstance(r,unicode):
48 #           return r.encode("utf8")
49
50     def eval_bool(self, expr):
51         if self.eval_object(expr):
52             return 1
53         else:
54             return 0
55
56 class QWebXml(object):
57     """QWeb Xml templating engine
58
59     The templating engine use a very simple syntax, "magic" xml attributes, to
60     produce any kind of texutal output (even non-xml).
61
62     QWebXml:
63         the template engine core implements the basic magic attributes:
64
65         t-att t-raw t-esc t-if t-foreach t-set t-call t-trim
66
67
68     - loader: function that return a template
69
70
71     """
72     def __init__(self, loader=None):
73         self.loader = loader
74         self.node = xml.dom.Node
75         self._t = {}
76         self._render_tag = {}
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)
83
84         self._render_att = {}
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)
89
90     def register_tag(self, tag, func):
91         self._render_tag[tag] = func
92
93     def add_template(self, x):
94         if hasattr(x, 'documentElement'):
95             dom = x
96         elif x.startswith("<?xml"):
97             dom = xml.dom.minidom.parseString(x)
98         else:
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
103
104     def get_template(self, name):
105         if name in self._t:
106             return self._t[name]
107         elif self.loader:
108             xml = self.loader(name)
109             self.add_template(xml)
110             if name in self._t:
111                 return self._t[name]
112         raise KeyError('qweb: template "%s" not found' % name)
113
114     def eval_object(self, expr, v):
115         return QWebEval(v).eval_object(expr)
116
117     def eval_str(self, expr, v):
118         return QWebEval(v).eval_str(expr)
119
120     def eval_format(self, expr, v):
121         return QWebEval(v).eval_format(expr)
122
123     def eval_bool(self, expr, v):
124         return QWebEval(v).eval_bool(expr)
125
126     def render(self, tname, v=None, out=None):
127         if v is None:
128             v = {}
129         return self.render_node(self.get_template(tname), v)
130
131     def render_node(self, e, v):
132         r = ""
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:
136             g_att = ""
137             t_render = None
138             t_att = {}
139             for (an, av) in e.attributes.items():
140                 an = str(an)
141                 if isinstance(av, types.UnicodeType):
142                     av = av.encode("utf8")
143                 else:
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)
149                             break
150                     else:
151                         if an[2:] in self._render_tag:
152                             t_render = an[2:]
153                         t_att[an[2:]] = av
154                 else:
155                     g_att += ' %s="%s"' % (an, cgi.escape(av, 1))
156             if t_render:
157                 if t_render in self._render_tag:
158                     r = self._render_tag[t_render](self, e, t_att, g_att, v)
159             else:
160                 r = self.render_element(e, t_att, g_att, v)
161         return r
162
163     def render_element(self, e, t_att, g_att, v, inner=None):
164         # e: element
165         # t_att: t-* attributes
166         # g_att: generated attributes
167         # v: values
168         # inner: optional innerXml
169         if inner:
170             g_inner = inner
171         else:
172             g_inner = []
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)
178         if trim == 0:
179             pass
180         elif trim == 'left':
181             inner = inner.lstrip()
182         elif trim == 'right':
183             inner = inner.rstrip()
184         elif trim == 'both':
185             inner = inner.strip()
186         if name == "t":
187             return inner
188         elif len(inner) or name not in self._void_elements:
189             return "<%s%s>%s</%s>" % (name, g_att, inner, name)
190         else:
191             return "<%s%s/>" % (name, g_att)
192
193     # Attributes
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)
199         else:
200             att, val = self.eval_object(av, v)
201         return ' %s="%s"' % (att, cgi.escape(val, 1))
202
203     # Tags
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)
207
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)
211
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)
215
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)
219
220     def render_tag_foreach(self, e, t_att, g_att, v):
221         expr = t_att["foreach"]
222         enum = self.eval_object(expr, v)
223         if enum is not None:
224             var = t_att.get('as', expr).replace('.', '_')
225             d = v.copy()
226             size = -1
227             if isinstance(enum, types.ListType):
228                 size = len(enum)
229             elif isinstance(enum, types.TupleType):
230                 size = len(enum)
231             elif hasattr(enum, 'count'):
232                 size = enum.count()
233             d["%s_size" % var] = size
234             d["%s_all" % var] = enum
235             index = 0
236             ru = []
237             for i in 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
244                 if index % 2:
245                     d["%s_parity" % var] = 'odd'
246                 else:
247                     d["%s_parity" % var] = 'even'
248                 if isinstance(i, types.DictType):
249                     d.update(i)
250                 else:
251                     d[var] = i
252                 ru.append(self.render_element(e, t_att, g_att, d))
253                 index += 1
254             return "".join(ru)
255         else:
256             return "qweb: t-foreach %s not found." % expr
257
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)
261         else:
262             return ""
263
264     def render_tag_call(self, e, t_att, g_att, v):
265         if "import" in t_att:
266             d = v
267         else:
268             d = v.copy()
269         d[0] = self.render_element(e, t_att, g_att, d)
270         return self.render(t_att["call"], d)
271
272     def render_tag_set(self, e, t_att, g_att, v):
273         if "value" in t_att:
274             v[t_att["set"]] = self.eval_object(t_att["value"], v)
275         else:
276             v[t_att["set"]] = self.render_element(e, t_att, g_att, v)
277         return ""
278
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>"""
281
282         record, field = t_att["field"].rsplit('.', 1)
283         record = self.eval_object(record, v)
284
285         inner = ""
286         field_type = record._model._all_columns.get(field).column._type
287         try:
288             if field_type == 'many2one':
289                 field_data = record.read([field])[0].get(field)
290                 inner = field_data and field_data[1] or ""
291             else:
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))
297             if e.tagName != 't':
298                 g_att += ''.join(
299                     ' %s="%s"' % (name, cgi.escape(str(value), True))
300                     for name, value in [
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),
305                     ]
306                 )
307         except AttributeError:
308             _logger.warning("t-field no field %s for model %s", field, record._model._name)
309
310         return self.render_element(e, t_att, g_att, v, str(inner))
311
312 # leave this, al.