Source Code for Module hm.app.lib.tags.macros

  1   
  2  from django import template 
  3  from django.template.loader import get_template 
  4  from django.template.context import Context 
  5   
  6  import settings 
  7   
  8  import utils 
  9  register = template.Library() 
 10   
 11   
 12   
 13  from django.template.loader_tags import BlockNode, ExtendsNode 
 14   
 15   
 16 -def capture_frame(context, nodelist, d=None): 
 17      if d == None: 
 18          d = {} 
 19      context.update(d) 
 20      nodelist.render(context) 
 21      context.pop() 
 22      return d 
 23   
 24 -def resolve_frame(frame, context, nodelist=None): 
 25      d = {} 
 26      basis = [frame] 
 27      while len(basis) > 0: 
 28          b, basis = basis[0], basis[1:] 
 29          #print "resolve_frame" 
 30          #print repr((b,basis)) 
 31          d.update(utils.resolve(b, context)) 
 32          if "_basis" in d: 
 33              b = d.pop("_basis") 
 34              if not isinstance(b, (list, tuple)): 
 35                  b = [b] 
 36              basis += b 
 37      if nodelist: 
 38          capture_frame(context, nodelist, d) 
 39      return d 
 40   
 41 -def build_frame(line, parser, defaults): 
 42      d = {} 
 43      basis = [] 
 44       
 45      vars = list(defaults) 
 46      args, kwargs = utils.split_args(line) 
 47      #print repr((vars, args, kwargs)) 
 48      for a in list(args[1:]): 
 49          if a.startswith("&"): 
 50              basis.append(a[1:]) 
 51          elif len(vars) > 0: 
 52              v = vars.pop(0) 
 53                   
 54              if isinstance(v, (list, tuple)) and len(v) >= 1: 
 55                  d[v[0]] = a 
 56              elif isinstance(v, (str, unicode)): 
 57                  d[v] = a 
 58          else: 
 59              if settings.TEMPLATE_DEBUG: 
 60                  raise RuntimeError("Too many arguments!") 
 61           
 62      for v in vars: 
 63          if isinstance(v, (list, tuple)): 
 64              if len(v) == 1: 
 65                  d[v[0]] = '' 
 66              elif len(v) > 1: 
 67                  d[v[0]] = v[1] 
 68          elif isinstance(v, (str, unicode)): 
 69              if settings.TEMPLATE_DEBUG: 
 70                  raise RuntimeError("Missing required argument: %s!" % v) 
 71       
 72      d.update(kwargs) 
 73      d["_basis"] = basis 
 74      return utils.parse_arg(d, parser) 
 75       
 76   
 77   
 78   
 79 -def name_ify_filter(s): 
 80      path = s.split(".") 
 81      if len(path) == 1: 
 82          return s 
 83      else: 
 84          return path[0]+'['+"][".join(path[1:])+']' 
 85  register.filter("name_ify", name_ify_filter) 
 86   
 87 -def id_ify_filter(s): 
 88      return "__".join(s.split(".")) 
 89  register.filter("id_ify", id_ify_filter) 
 90   
 91   
 92   
 93   
 94 -class PaneNode(BlockNode): 
 95 -    def __init__(self, kwargs, nodelist): 
 96          self.kwargs = kwargs 
 97          self.nodelist = nodelist 
 98          try: 
 99              self.template = self.get_template() 
100          except: 
101              if settings.TEMPLATE_DEBUG: 
102                  raise 
103              self.template = None 
104               
105 -    def get_template(self): 
106          block = BlockNode("content", self.nodelist) 
107          template = get_template("helpers/pane.html") 
108          template.nodelist[0].nodelist += block 
109          return template 
110               
111 -    def render(self, context): 
112          d = resolve_frame(self.kwargs, context, self.nodelist) 
113          context.update({ "pane": d }) 
114           
115          try: 
116              if self.template: 
117                  result = self.template.render(context) 
118              else: 
119                  result = '' 
120          except Exception, e: 
121              print "Exception: PaneNode.render()" 
122              print repr(e) 
123              print str(e) 
124          context.pop() 
125          return result 
126       
127 -def do_pane(parser, token): 
128      try: 
129          kwargs = build_frame(token.contents, parser, ["id", "title"]) 
130          nodelist = parser.parse(('endpane', 'end')) 
131          parser.delete_first_token() 
132          return PaneNode(kwargs, nodelist) 
133      except Exception, e: 
134          print "Exception: do_pane" 
135          print repr(e) 
136          print str(e) 
137  register.tag('pane', do_pane) 
138   
139   
140  #class SlotNode(template.Node): 
141  #    def __init__(self, name): 
142  #        self.name = name 
143  #        self.selector = selector 
144  #        self.contents = [] 
145  #         
146  #    def render(self, context): 
147  #        old_contents = self.contents 
148  #        self.contents = [] 
149  #        context.update({ "slot": self }) 
150  #        if self.template: 
151  #            result = self.template.render(context) 
152  #        else: 
153  #            result = '' 
154  #        context.pop() 
155  #        return result 
156  #     
157  #def do_slot(parser, token): 
158  #    args, kwargs = utils.split_args(token.contents) 
159  #    name = args[1] #utils.parse_arg(args[1], parser) 
160  #    selector = utils.parse_arg(args[2], parser) 
161  #    #print repr(varname) 
162  #    return SlotNode(name, selector) 
163  #register.tag('slot', do_slot) 
164   
165   
166 -class StaticExtendsNode(template.Node): 
167 -    def __init__(self, nodelist, parent_template): 
168          self.nodelist = nodelist 
169          self.parent_template = parent_template 
170           
171 -    def render(self, context): 
172          #print "StaticExtendsNode:" 
173          #print repr(context) 
174           
175          compiled_parent = self.parent_template 
176          parent_is_child = isinstance(compiled_parent.nodelist[0], ExtendsNode) 
177          parent_blocks = dict([(n.name, n) for n in compiled_parent.nodelist.get_nodes_by_type(BlockNode)]) 
178          for block_node in self.nodelist.get_nodes_by_type(BlockNode): 
179              # Check for a BlockNode with this node's name, and replace it if found. 
180              try: 
181                  parent_block = parent_blocks[block_node.name] 
182              except KeyError: 
183                  # This BlockNode wasn't found in the parent template, but the 
184                  # parent block might be defined in the parent's *parent*, so we 
185                  # add this BlockNode to the parent's ExtendsNode nodelist, so 
186                  # it'll be checked when the parent node's render() is called. 
187                  if parent_is_child: 
188                      compiled_parent.nodelist[0].nodelist.append(block_node) 
189              else: 
190                  # Keep any existing parents and add a new one. Used by BlockNode. 
191                  parent_block.parent = block_node.parent 
192                  parent_block.add_parent(parent_block.nodelist) 
193                  parent_block.nodelist = block_node.nodelist 
194          return compiled_parent.render(context) 
195   
196   
197 -class TableFormNode(template.Node): 
198 -    def __init__(self, kwargs, nodelist): 
199          self.kwargs = kwargs 
200          self.nodelist = nodelist 
201          try: 
202              self.template = self.get_template() 
203          except: 
204              if settings.TEMPLATE_DEBUG: 
205                  raise 
206              self.template = None 
207       
208 -    def get_template(self): 
209          block = BlockNode("fields", self.nodelist) 
210          return StaticExtendsNode(template.NodeList([block]), 
211                                   get_template("helpers/table_form.html")) 
212           
213 -    def render(self, context): 
214          d = resolve_frame(self.kwargs, context, self.nodelist) 
215          context.update({"form": d}) 
216          try: 
217              if self.template: 
218                  result = self.template.render(context) 
219              else: 
220                  result = '' 
221          except Exception, e: 
222              result = str(e) 
223          context.pop() 
224          return result 
225       
226 -def do_tableform(parser, token): 
227      kwargs = build_frame(token.contents, parser, ["name", "action", ["method", '"POST"']]) 
228      nodelist = parser.parse(('endtableform', 'endform', 'end')) 
229      parser.delete_first_token() 
230      return TableFormNode(kwargs, nodelist) 
231  register.tag('tableform', do_tableform) 
232   
233   
234   
235  #class MacroNode(template.Node): pass 
236  # 
237  #     
238  #def macro_nodelist(kls_name, tag_name, template_file,  
239  #                   blockname="content" varname="data", args=None): 
240  #    """ 
241  #    """ 
242  #    def self_init(self, kwargs, nodelist=None): 
243  #        self.kwargs = kwargs 
244  #        self.nodelist = nodelist 
245  #        try: 
246  #            self.template = get_template(template_file) 
247  #        except Exception, e: 
248  #            if settings.TEMPLATE_DEBUG: 
249  #                raise 
250  #            self.template = None 
251  #     
252  #    def render(self, context): 
253  #        d = resolve_frame(self.kwargs, context, self.nodelist) 
254  #        context.update({ varname: d }) 
255  #        if self.template: 
256  #            result = self.template.render(context) 
257  #        else: 
258  #            result = '' 
259  #        context.pop() 
260  #        return result 
261  #     
262  #    NodeClass = type(kls_name, (MacroNode), 
263  #                     { "__init__": self_init, 
264  #                       "render"  : self_render }) 
265  #     
266  #    def do_macro(parser, token): 
267  #        try: 
268  #            kwargs = build_frame(token.contents, parser, args or []) 
269  #        except Exception, e: 
270  #            print repr(e) 
271  #            print str(e) 
272  #        nodelist = parser.parse(('end%sfield' % tag_name, 'endfield', 'end')) 
273  #        parser.delete_first_token() 
274  #        return NodeClass(kwargs, nodelist) 
275  #     
276  #    register.tag(tag_name, do_macro) 
277  #    return NodeClass 
278  # 
279  # 
280  #def macro_node(kls_name, tag_name, template_file, varname="data", args=None): 
281  #    """ 
282  #    @param nodelist_type: "data", or "html" 
283  #    """ 
284  #    def self_init(self, kwargs, nodelist=None): 
285  #        self.kwargs = kwargs 
286  #        self.nodelist = nodelist 
287  #        try: 
288  #            self.template = get_template(template_file) 
289  #        except Exception, e: 
290  #            if settings.TEMPLATE_DEBUG: 
291  #                raise 
292  #            self.template = None 
293  #     
294  #    def render(self, context): 
295  #        d = resolve_frame(self.kwargs, context, self.nodelist) 
296  #        context.update({ varname: d }) 
297  #        if self.template: 
298  #            result = self.template.render(context) 
299  #        else: 
300  #            result = '' 
301  #        context.pop() 
302  #        return result 
303  #     
304  #    NodeClass = type(kls_name, (MacroNode), 
305  #                     { "__init__": self_init, 
306  #                       "render"  : self_render }) 
307  #     
308  #    def do_macro(parser, token): 
309  #        try: 
310  #            kwargs = build_frame(token.contents, parser, args or []) 
311  #        except Exception, e: 
312  #            print repr(e) 
313  #            print str(e) 
314  #        nodelist = parser.parse(('end%sfield' % tag_name, 'endfield', 'end')) 
315  #        parser.delete_first_token() 
316  #        return NodeClass(kwargs, nodelist) 
317  #     
318  #    register.tag(tag_name, do_macro) 
319  #    return NodeClass 
320   
321   
322  #class GenericMacroNode(template.Node): 
323  #    def __init__(self, kwargs, nodelist=None): 
324  #        self.kwargs = kwargs 
325  #        self.nodelist = nodelist 
326  #    def render(self, context): 
327  #        raise RuntimeError("Cannot render GenericMacroNode: %s!" % type(self)) 
328  # 
329  #class FormNode(GenericMacroNode):  pass 
330  #class FieldNode(GenericMacroNode): pass 
331  #class ErrorNode(GenericMacroNode): pass 
332  # 
333  #def make_macro_container(tag, tag_type, mappings): 
334  #    def do_macro_container(parser, token): 
335  #        kwargs = build_frame(token.contents, parser, ["path"]) 
336  #        nodelist = parser.parse(('end%s%s' % (tag, tag_type),  
337  #                                 'end%s' % tag, 
338  #                                 'end')) 
339  #        parser.delete_first_token() 
340  #        for interface, implementation in mappings.items(): 
341  #            for node in nodelist.get_nodes_by_type(interface): 
342  #                 
343           
344   
345 -class TableFieldNode(template.Node): 
346 -    def __init__(self, kwargs, nodelist=None): 
347          self.kwargs = kwargs 
348          self.nodelist = nodelist or template.NodeList() 
349          try: 
350              self.template = self.get_template() 
351          except Exception, e: 
352              if settings.TEMPLATE_DEBUG: 
353                  raise 
354              self.template = None 
355               
356 -    def get_template(self): 
357          return get_template("helpers/table_field.html") 
358   
359 -    def render(self, context): 
360          d = resolve_frame(self.kwargs, context, self.nodelist) 
361          #print repr(d) 
362          context.update({ "field": d }) 
363           
364          if self.template: 
365              result = self.template.render(context) 
366          else: 
367              result = '' 
368           
369          context.pop() 
370          return result 
371   
372 -def do_tablefield_block(parser, token): 
373      kwargs = build_frame(token.contents, parser, ["path", ["type", '"text"']]) 
374      nodelist = parser.parse(('endtablefield', 'endfield', 'end')) 
375      parser.delete_first_token() 
376      return TableFieldNode(kwargs, nodelist) 
377  register.tag('field_block', do_tablefield_block) 
378   
379 -def do_tablefield(parser, token): 
380      kwargs = build_frame(token.contents, parser, ["path", ["type", '"text"']]) 
381      return TableFieldNode(kwargs) 
382  register.tag('field', do_tablefield) 
383   
384   
385   
386   
387 -class ErrorsNode(template.Node): 
388 -    def __init__(self, varname): 
389          self.varname = varname 
390          try: 
391              t = get_template("helpers/errors.html") 
392              self.template = t 
393          except: 
394              if settings.TEMPLATE_DEBUG: 
395                  raise 
396              self.template = None 
397   
398 -    def render(self, context): 
399          c = Context({ "errors": utils.resolve(self.varname, context), }) 
400          if self.template: 
401              result = self.template.render(c) 
402          else: 
403              result = '' 
404          return result 
405       
406 -def do_errors(parser, token): 
407      args, kwargs = utils.split_args(token.contents) 
408      varname = utils.parse_arg(args[1], parser) 
409      return ErrorsNode(varname) 
410  register.tag('errors', do_errors) 
411