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