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         d = {
  17             'True': True,
  18             'False': False,
  19             'None': None,
  20             'str': str,
  21             'globals': locals,
  22             'locals': locals,
  23             'bool': bool,
  24             'dict': dict,
  25             'list': list,
  26             'tuple': tuple,
  27             'map': map,
  28             'abs': abs,
  29             'min': min,
  30             'max': max,
  31             'reduce': reduce,
  32             'filter': filter,
  33             'round': round,
  34             'len': len,
  35             'set': set
  36         }
  37         d.update(data)
  38         dict.__init__(self, d)
  39         self['defined'] = lambda key: key in self
  40
  41     def __getitem__(self, key):
  42         if key in self:
  43             return self.get(key)
  44         elif not self.undefined_handler:
  45             raise NameError("QWeb: name %r is not defined while rendering template %r" % (key, self.get('__template__')))
  46         else:
  47             return self.get(key, self.undefined_handler(key, self))
  48
  49 class QWebXml(object):
  50     """QWeb Xml templating engine
  51
  52     The templating engine use a very simple syntax, "magic" xml attributes, to
  53     produce any kind of texutal output (even non-xml).
  54
  55     QWebXml:
  56         the template engine core implements the basic magic attributes:
  57
  58         t-att t-raw t-esc t-if t-foreach t-set t-call t-trim
  59
  60
  61     - loader: function that return a template
  62
  63
  64     """
  65     def __init__(self, loader=None, undefined_handler=None):
  66         self.loader = loader
  67         self.undefined_handler = undefined_handler
  68         self.node = xml.dom.Node
  69         self._t = {}
  70         self._render_tag = {}
  71         self._format_regex = re.compile('#\{(.*?)\}')
  72         self._void_elements = set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
  73                                   'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])
  74         prefix = 'render_tag_'
  75         for i in [j for j in dir(self) if j.startswith(prefix)]:
  76             name = i[len(prefix):].replace('_', '-')
  77             self._render_tag[name] = getattr(self.__class__, i)
  78
  79         self._render_att = {}
  80         prefix = 'render_att_'
  81         for i in [j for j in dir(self) if j.startswith(prefix)]:
  82             name = i[len(prefix):].replace('_', '-')
  83             self._render_att[name] = getattr(self.__class__, i)
  84
  85     def register_tag(self, tag, func):
  86         self._render_tag[tag] = func
  87
  88     def add_template(self, x):
  89         if hasattr(x, 'documentElement'):
  90             dom = x
  91         elif x.startswith("<?xml"):
  92             dom = xml.dom.minidom.parseString(x)
  93         else:
  94             dom = xml.dom.minidom.parse(x)
  95         for n in dom.documentElement.childNodes:
  96             if n.getAttribute('t-name'):
  97                 self._t[str(n.getAttribute("t-name"))] = n
  98
  99     def get_template(self, name):
 100         if name in self._t:
 101             return self._t[name]
 102         elif self.loader:
 103             xml = self.loader(name)
 104             self.add_template(xml)
 105             if name in self._t:
 106                 return self._t[name]
 107         raise KeyError('qweb: template "%s" not found' % name)
 108
 109     def eval(self, expr, v):
 110         try:
 111             return eval(expr, None, v)
 112         except Exception:
 113             raise SyntaxError("QWeb: invalid expression %r while rendering template '%s'" % (expr, v.get('__template__')))
 114
 115     def eval_object(self, expr, v):
 116         return self.eval(expr, v)
 117
 118     def eval_str(self, expr, v):
 119         if expr == "0":
 120             return v.get(0, '')
 121         val = self.eval(expr, v)
 122         if isinstance(val, unicode):
 123             return val.encode("utf8")
 124         return str(val)
 125
 126     def eval_format(self, expr, v):
 127         use_native = True
 128         for m in self._format_regex.finditer(expr):
 129             use_native = False
 130             expr = expr.replace(m.group(), self.eval_str(m.groups()[0], v))
 131         if not use_native:
 132             return expr
 133         else:
 134             try:
 135                 return str(expr % v)
 136             except:
 137                 raise Exception("QWeb: format error '%s' " % expr)
 138
 139     def eval_bool(self, expr, v):
 140         val = self.eval(expr, v)
 141         if val:
 142             return 1
 143         else:
 144             return 0
 145
 146     def render(self, tname, v=None, out=None):
 147         if v is None:
 148             v = {}
 149         v['__template__'] = tname
 150         stack = v.get('__stack__', [])
 151         if stack:
 152             v['__caller__'] = stack[-1]
 153         stack.append(tname)
 154         v['__stack__'] = stack
 155         v = QWebContext(v, self.undefined_handler)
 156         return self.render_node(self.get_template(tname), v)
 157
 158     def render_node(self, e, v):
 159         r = ""
 160         if e.nodeType == self.node.TEXT_NODE or e.nodeType == self.node.CDATA_SECTION_NODE:
 161             r = e.data.encode("utf8")
 162         elif e.nodeType == self.node.ELEMENT_NODE:
 163             g_att = ""
 164             t_render = None
 165             t_att = {}
 166             for (an, av) in e.attributes.items():
 167                 an = str(an)
 168                 if isinstance(av, types.UnicodeType):
 169                     av = av.encode("utf8")
 170                 else:
 171                     av = av.nodeValue.encode("utf8")
 172                 if an.startswith("t-"):
 173                     for i in self._render_att:
 174                         if an[2:].startswith(i):
 175                             g_att += self._render_att[i](self, e, an, av, v)
 176                             break
 177                     else:
 178                         if an[2:] in self._render_tag:
 179                             t_render = an[2:]
 180                         t_att[an[2:]] = av
 181                 else:
 182                     g_att += ' %s="%s"' % (an, cgi.escape(av, 1))
 183             if t_render:
 184                 if t_render in self._render_tag:
 185                     r = self._render_tag[t_render](self, e, t_att, g_att, v)
 186             else:
 187                 r = self.render_element(e, t_att, g_att, v)
 188         return r
 189
 190     def render_element(self, e, t_att, g_att, v, inner=None):
 191         # e: element
 192         # t_att: t-* attributes
 193         # g_att: generated attributes
 194         # v: values
 195         # inner: optional innerXml
 196         if inner:
 197             g_inner = inner
 198         else:
 199             g_inner = []
 200             for n in e.childNodes:
 201                 g_inner.append(self.render_node(n, v))
 202         name = str(e.nodeName)
 203         inner = "".join(g_inner)
 204         trim = t_att.get("trim", 0)
 205         if trim == 0:
 206             pass
 207         elif trim == 'left':
 208             inner = inner.lstrip()
 209         elif trim == 'right':
 210             inner = inner.rstrip()
 211         elif trim == 'both':
 212             inner = inner.strip()
 213         if name == "t":
 214             return inner
 215         elif len(inner) or name not in self._void_elements:
 216             return "<%s%s>%s</%s>" % (name, g_att, inner, name)
 217         else:
 218             return "<%s%s/>" % (name, g_att)
 219
 220     # Attributes
 221     def render_att_att(self, e, an, av, v):
 222         if an.startswith("t-attf-"):
 223             att, val = an[7:], self.eval_format(av, v)
 224         elif an.startswith("t-att-"):
 225             att, val = an[6:], self.eval_str(av, v)
 226         else:
 227             att, val = self.eval_object(av, v)
 228         return ' %s="%s"' % (att, cgi.escape(val, 1))
 229
 230     # Tags
 231     def render_tag_raw(self, e, t_att, g_att, v):
 232         inner = self.eval_str(t_att["raw"], v)
 233         return self.render_element(e, t_att, g_att, v, inner)
 234
 235     def render_tag_rawf(self, e, t_att, g_att, v):
 236         inner = self.eval_format(t_att["rawf"], v)
 237         return self.render_element(e, t_att, g_att, v, inner)
 238
 239     def render_tag_esc(self, e, t_att, g_att, v):
 240         inner = cgi.escape(self.eval_str(t_att["esc"], v))
 241         return self.render_element(e, t_att, g_att, v, inner)
 242
 243     def render_tag_escf(self, e, t_att, g_att, v):
 244         inner = cgi.escape(self.eval_format(t_att["escf"], v))
 245         return self.render_element(e, t_att, g_att, v, inner)
 246
 247     def render_tag_foreach(self, e, t_att, g_att, v):
 248         expr = t_att["foreach"]
 249         enum = self.eval_object(expr, v)
 250         if enum is not None:
 251             var = t_att.get('as', expr).replace('.', '_')
 252             d = QWebContext(v.copy(), self.undefined_handler)
 253             size = -1
 254             if isinstance(enum, types.ListType):
 255                 size = len(enum)
 256             elif isinstance(enum, types.TupleType):
 257                 size = len(enum)
 258             elif hasattr(enum, 'count'):
 259                 size = enum.count()
 260             d["%s_size" % var] = size
 261             d["%s_all" % var] = enum
 262             index = 0
 263             ru = []
 264             for i in enum:
 265                 d["%s_value" % var] = i
 266                 d["%s_index" % var] = index
 267                 d["%s_first" % var] = index == 0
 268                 d["%s_even" % var] = index % 2
 269                 d["%s_odd" % var] = (index + 1) % 2
 270                 d["%s_last" % var] = index + 1 == size
 271                 if index % 2:
 272                     d["%s_parity" % var] = 'odd'
 273                 else:
 274                     d["%s_parity" % var] = 'even'
 275                 if isinstance(i, types.DictType):
 276                     d.update(i)
 277                 else:
 278                     d[var] = i
 279                 ru.append(self.render_element(e, t_att, g_att, d))
 280                 index += 1
 281             return "".join(ru)
 282         else:
 283             return "qweb: t-foreach %s not found." % expr
 284
 285     def render_tag_if(self, e, t_att, g_att, v):
 286         if self.eval_bool(t_att["if"], v):
 287             return self.render_element(e, t_att, g_att, v)
 288         else:
 289             return ""
 290
 291     def render_tag_call(self, e, t_att, g_att, v):
 292         if "import" in t_att:
 293             d = v
 294         else:
 295             d = QWebContext(v.copy(), self.undefined_handler)
 296         d[0] = self.render_element(e, t_att, g_att, d)
 297         return self.render(t_att["call"], d)
 298
 299     def render_tag_set(self, e, t_att, g_att, v):
 300         if "value" in t_att:
 301             v[t_att["set"]] = self.eval_object(t_att["value"], v)
 302         elif "valuef" in t_att:
 303             v[t_att["set"]] = self.eval_format(t_att["valuef"], v)
 304         else:
 305             v[t_att["set"]] = self.render_element(e, t_att, g_att, v)
 306         return ""
 307
 308     def render_tag_field(self, e, t_att, g_att, v):
 309         """ eg: <span t-record="browse_record(res.partner, 1)" t-field="phone">+1 555 555 8069</span>"""
 310
 311         record, field = t_att["field"].rsplit('.', 1)
 312         record = self.eval_object(record, v)
 313
 314         inner = ""
 315         field_type = record._model._all_columns.get(field).column._type
 316         try:
 317             if field_type == 'many2one':
 318                 field_data = record.read([field])[0].get(field)
 319                 inner = field_data and field_data[1] or ""
 320             else:
 321                 inner = getattr(record, field) or ""
 322             if isinstance(inner, types.UnicodeType):
 323                 inner = inner.encode("utf8")
 324             if field_type != 'html':
 325                 cgi.escape(str(inner))
 326             if e.tagName != 't':
 327                 g_att += ''.join(
 328                     ' %s="%s"' % (name, cgi.escape(str(value), True))
 329                     for name, value in [
 330                         ('data-oe-model', record._model._name),
 331                         ('data-oe-id', str(record.id)),
 332                         ('data-oe-field', field),
 333                         ('data-oe-type', field_type),
 334                     ]
 335                 )
 336         except AttributeError:
 337             _logger.warning("t-field no field %s for model %s", field, record._model._name)
 338
 339         return self.render_element(e, t_att, g_att, v, str(inner))
 340
 341 # leave this, al.