openerp/tools/qweb.py

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