openerp/tools/qweb.py

   1 import cgi
   2 import logging
   3 import re
   4 import types
   5
   6 #from openerp.tools.safe_eval import safe_eval as eval
   7
   8 import xml   # FIXME use lxml
   9 import xml.dom.minidom
  10
  11 _logger = logging.getLogger(__name__)
  12
  13 class QWebContext(dict):
  14     def __init__(self, data, undefined_handler=None):
  15         self.undefined_handler = undefined_handler
  16         dict.__init__(self, data)
  17         self['defined'] = lambda key: key in self
  18
  19     def __getitem__(self, key):
  20         if key in self:
  21             return self.get(key)
  22         elif not self.undefined_handler:
  23             raise NameError("QWeb: name %r is not defined while rendering template %r" % (key, self.get('__template__')))
  24         else:
  25             return self.get(key, self.undefined_handler(key, self))
  26
  27 class QWebXml(object):
  28     """QWeb Xml templating engine
  29
  30     The templating engine use a very simple syntax, "magic" xml attributes, to
  31     produce any kind of texutal output (even non-xml).
  32
  33     QWebXml:
  34         the template engine core implements the basic magic attributes:
  35
  36         t-att t-raw t-esc t-if t-foreach t-set t-call t-trim
  37
  38
  39     - loader: function that return a template
  40
  41
  42     """
  43     def __init__(self, loader=None, undefined_handler=None):
  44         self.loader = loader
  45         self.undefined_handler = undefined_handler
  46         self.node = xml.dom.Node
  47         self._t = {}
  48         self._render_tag = {}
  49         self._format_regex = re.compile('#\{(.*?)\}')
  50         self._void_elements = set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
  51                                   'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])
  52         prefix = 'render_tag_'
  53         for i in [j for j in dir(self) if j.startswith(prefix)]:
  54             name = i[len(prefix):].replace('_', '-')
  55             self._render_tag[name] = getattr(self.__class__, i)
  56
  57         self._render_att = {}
  58         prefix = 'render_att_'
  59         for i in [j for j in dir(self) if j.startswith(prefix)]:
  60             name = i[len(prefix):].replace('_', '-')
  61             self._render_att[name] = getattr(self.__class__, i)
  62
  63     def register_tag(self, tag, func):
  64         self._render_tag[tag] = func
  65
  66     def add_template(self, x):
  67         if hasattr(x, 'documentElement'):
  68             dom = x
  69         elif x.startswith("<?xml"):
  70             dom = xml.dom.minidom.parseString(x)
  71         else:
  72             dom = xml.dom.minidom.parse(x)
  73         for n in dom.documentElement.childNodes:
  74             if n.nodeName == "t":
  75                 self._t[str(n.getAttribute("t-name"))] = n
  76
  77     def get_template(self, name):
  78         if name in self._t:
  79             return self._t[name]
  80         elif self.loader:
  81             xml = self.loader(name)
  82             self.add_template(xml)
  83             if name in self._t:
  84                 return self._t[name]
  85         raise KeyError('qweb: template "%s" not found' % name)
  86
  87     def eval(self, expr, v):
  88         try:
  89             return eval(expr, None, v)
  90         except Exception:
  91             raise SyntaxError("QWeb: invalid expression %r while rendering template '%s'" % (expr, v.get('__template__')))
  92
  93     def eval_object(self, expr, v):
  94         return self.eval(expr, v)
  95
  96     def eval_str(self, expr, v):
  97         if expr == "0":
  98             return v.get(0, '')
  99         val = self.eval(expr, v)
 100         if isinstance(val, unicode):
 101             return val.encode("utf8")
 102         return str(val)
 103
 104     def eval_format(self, expr, v):
 105         use_native = True
 106         for m in self._format_regex.finditer(expr):
 107             use_native = False
 108             expr = expr.replace(m.group(), self.eval(m.groups()[0], v))
 109         if not use_native:
 110             return expr
 111         else:
 112             try:
 113                 return str(expr % v)
 114             except:
 115                 raise Exception("QWeb: format error '%s' " % expr)
 116
 117     def eval_bool(self, expr, v):
 118         val = self.eval(expr, v)
 119         if val:
 120             return 1
 121         else:
 122             return 0
 123
 124     def render(self, tname, v=None, out=None):
 125         if v is None:
 126             v = {}
 127         v['__template__'] = tname
 128         v = QWebContext(v, self.undefined_handler)
 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 = QWebContext(v.copy(), self.undefined_handler)
 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 = QWebContext(v.copy(), self.undefined_handler)
 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.