Changeset 5512 for django/branches/boulder-oracle-sprint/django/template
- Timestamp:
- 06/22/07 11:56:04 (2 years ago)
- Files:
-
- django/branches/boulder-oracle-sprint/django/template/defaulttags.py (modified) (25 diffs)
- django/branches/boulder-oracle-sprint/django/template/__init__.py (modified) (10 diffs)
- django/branches/boulder-oracle-sprint/django/template/loader.py (modified) (2 diffs)
- django/branches/boulder-oracle-sprint/django/template/loader_tags.py (modified) (5 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
django/branches/boulder-oracle-sprint/django/template/defaulttags.py
r5491 r5512 16 16 yield data[index] 17 17 18 18 19 register = Library() 19 20 20 21 class CommentNode(Node): 21 def iter_render(self, context):22 return ()22 def render(self, context): 23 return '' 23 24 24 25 class CycleNode(Node): … … 29 30 self.variable_name = variable_name 30 31 31 def iter_render(self, context):32 return (self.render(context),)33 34 32 def render(self, context): 35 33 self.counter += 1 … … 40 38 41 39 class DebugNode(Node): 42 def iter_render(self, context):40 def render(self, context): 43 41 from pprint import pformat 44 for val in context:45 yield pformat(val)46 yield "\n\n"47 yield pformat(sys.modules)42 output = [pformat(val) for val in context] 43 output.append('\n\n') 44 output.append(pformat(sys.modules)) 45 return ''.join(output) 48 46 49 47 class FilterNode(Node): … … 51 49 self.filter_expr, self.nodelist = filter_expr, nodelist 52 50 53 def iter_render(self, context):51 def render(self, context): 54 52 output = self.nodelist.render(context) 55 53 # apply filters … … 57 55 filtered = self.filter_expr.resolve(context) 58 56 context.pop() 59 return (filtered,)57 return filtered 60 58 61 59 class FirstOfNode(Node): 62 60 def __init__(self, vars): 63 61 self.vars = vars 64 65 def iter_render(self, context):66 return (self.render(context),)67 62 68 63 def render(self, context): … … 101 96 return nodes 102 97 103 def iter_render(self, context): 98 def render(self, context): 99 nodelist = NodeList() 104 100 if 'forloop' in context: 105 101 parentloop = context['forloop'] … … 109 105 try: 110 106 values = self.sequence.resolve(context, True) 111 if values is None:112 values = ()113 elif not hasattr(values, '__len__'):114 values = list(values)115 107 except VariableDoesNotExist: 116 values = () 108 values = [] 109 if values is None: 110 values = [] 111 if not hasattr(values, '__len__'): 112 values = list(values) 117 113 len_values = len(values) 118 114 if self.reversed: … … 133 129 } 134 130 if unpack: 135 # If there are multiple loop variables, unpack the item into 136 # them. 131 # If there are multiple loop variables, unpack the item into them. 137 132 context.update(dict(zip(self.loopvars, item))) 138 133 else: 139 134 context[self.loopvars[0]] = item 140 141 # We inline this to avoid the overhead since ForNode is pretty142 # common.143 135 for node in self.nodelist_loop: 144 for chunk in node.iter_render(context): 145 yield chunk 136 nodelist.append(node.render(context)) 146 137 if unpack: 147 138 # The loop variables were pushed on to the context so pop them … … 152 143 context.pop() 153 144 context.pop() 145 return nodelist.render(context) 154 146 155 147 class IfChangedNode(Node): … … 159 151 self._varlist = varlist 160 152 161 def iter_render(self, context):153 def render(self, context): 162 154 if 'forloop' in context and context['forloop']['first']: 163 155 self._last_seen = None … … 177 169 context.push() 178 170 context['ifchanged'] = {'firstloop': firstloop} 179 for chunk in self.nodelist.iter_render(context): 180 yield chunk 171 content = self.nodelist.render(context) 181 172 context.pop() 173 return content 174 else: 175 return '' 182 176 183 177 class IfEqualNode(Node): … … 190 184 return "<IfEqualNode>" 191 185 192 def iter_render(self, context):186 def render(self, context): 193 187 try: 194 188 val1 = resolve_variable(self.var1, context) … … 200 194 val2 = None 201 195 if (self.negate and val1 != val2) or (not self.negate and val1 == val2): 202 return self.nodelist_true. iter_render(context)203 return self.nodelist_false. iter_render(context)196 return self.nodelist_true.render(context) 197 return self.nodelist_false.render(context) 204 198 205 199 class IfNode(Node): … … 226 220 return nodes 227 221 228 def iter_render(self, context):222 def render(self, context): 229 223 if self.link_type == IfNode.LinkTypes.or_: 230 224 for ifnot, bool_expr in self.bool_exprs: … … 234 228 value = None 235 229 if (value and not ifnot) or (ifnot and not value): 236 return self.nodelist_true. iter_render(context)237 return self.nodelist_false. iter_render(context)230 return self.nodelist_true.render(context) 231 return self.nodelist_false.render(context) 238 232 else: 239 233 for ifnot, bool_expr in self.bool_exprs: … … 243 237 value = None 244 238 if not ((value and not ifnot) or (ifnot and not value)): 245 return self.nodelist_false. iter_render(context)246 return self.nodelist_true. iter_render(context)239 return self.nodelist_false.render(context) 240 return self.nodelist_true.render(context) 247 241 248 242 class LinkTypes: … … 255 249 self.var_name = var_name 256 250 257 def iter_render(self, context):251 def render(self, context): 258 252 obj_list = self.target.resolve(context, True) 259 253 if obj_list == None: # target_var wasn't found in context; fail silently 260 254 context[self.var_name] = [] 261 return ()255 return '' 262 256 # List of dictionaries in the format 263 257 # {'grouper': 'key', 'list': [list of contents]}. 264 258 context[self.var_name] = [{'grouper':key, 'list':list(val)} for key, val in 265 259 groupby(obj_list, lambda v, f=self.expression.resolve: f(v, True))] 266 return ()260 return '' 267 261 268 262 def include_is_allowed(filepath): … … 276 270 self.filepath, self.parsed = filepath, parsed 277 271 278 def iter_render(self, context):272 def render(self, context): 279 273 if not include_is_allowed(self.filepath): 280 274 if settings.DEBUG: 281 return ("[Didn't have permission to include file]",)275 return "[Didn't have permission to include file]" 282 276 else: 283 277 return '' # Fail silently for invalid includes. … … 290 284 if self.parsed: 291 285 try: 292 return Template(output, name=self.filepath).iter_render(context) 286 t = Template(output, name=self.filepath) 287 return t.render(context) 293 288 except TemplateSyntaxError, e: 294 289 if settings.DEBUG: … … 296 291 else: 297 292 return '' # Fail silently for invalid included templates. 298 return (output,)293 return output 299 294 300 295 class LoadNode(Node): 301 def iter_render(self, context):302 return ()296 def render(self, context): 297 return '' 303 298 304 299 class NowNode(Node): 305 300 def __init__(self, format_string): 306 301 self.format_string = format_string 307 308 def iter_render(self, context):309 return (self.render(context),)310 302 311 303 def render(self, context): … … 337 329 self.tagtype = tagtype 338 330 339 def iter_render(self, context):340 return (self.render(context),)341 342 331 def render(self, context): 343 332 return self.mapping.get(self.tagtype, '') … … 349 338 self.kwargs = kwargs 350 339 351 def iter_render(self, context):340 def render(self, context): 352 341 from django.core.urlresolvers import reverse, NoReverseMatch 353 342 args = [arg.resolve(context) for arg in self.args] 354 343 kwargs = dict([(k, v.resolve(context)) for k, v in self.kwargs.items()]) 355 344 try: 356 return (reverse(self.view_name, args=args, kwargs=kwargs),)345 return reverse(self.view_name, args=args, kwargs=kwargs) 357 346 except NoReverseMatch: 358 347 try: … … 360 349 return reverse(project_name + '.' + self.view_name, args=args, kwargs=kwargs) 361 350 except NoReverseMatch: 362 return ()351 return '' 363 352 364 353 class WidthRatioNode(Node): … … 367 356 self.max_expr = max_expr 368 357 self.max_width = max_width 369 370 def iter_render(self, context):371 return (self.render(context),)372 358 373 359 def render(self, context): … … 394 380 return "<WithNode>" 395 381 396 def iter_render(self, context):382 def render(self, context): 397 383 val = self.var.resolve(context) 398 384 context.push() 399 385 context[self.name] = val 400 for chunk in self.nodelist.iter_render(context): 401 yield chunk 386 output = self.nodelist.render(context) 402 387 context.pop() 388 return output 403 389 404 390 #@register.tag django/branches/boulder-oracle-sprint/django/template/__init__.py
r5491 r5512 56 56 """ 57 57 import re 58 import types59 58 from inspect import getargspec 60 59 from django.conf import settings … … 169 168 yield subnode 170 169 171 def iter_render(self, context):170 def render(self, context): 172 171 "Display stage -- can be called many times" 173 return self.nodelist.iter_render(context) 174 175 def render(self, context): 176 return ''.join(self.iter_render(context)) 172 return self.nodelist.render(context) 177 173 178 174 def compile_string(template_string, origin): … … 700 696 return current 701 697 702 class NodeBase(type):703 def __new__(cls, name, bases, attrs):704 """705 Ensures that either a 'render' or 'render_iter' method is defined on706 any Node sub-class. This avoids potential infinite loops at runtime.707 """708 if not (isinstance(attrs.get('render'), types.FunctionType) or709 isinstance(attrs.get('iter_render'), types.FunctionType)):710 raise TypeError('Unable to create Node subclass without either "render" or "iter_render" method.')711 return type.__new__(cls, name, bases, attrs)712 713 698 class Node(object): 714 __metaclass__ = NodeBase715 716 def iter_render(self, context):717 return (self.render(context),)718 719 699 def render(self, context): 720 700 "Return the node rendered as a string" 721 return ''.join(self.iter_render(context))701 pass 722 702 723 703 def __iter__(self): … … 735 715 class NodeList(list): 736 716 def render(self, context): 737 return ''.join(self.iter_render(context)) 738 739 def iter_render(self, context): 717 bits = [] 740 718 for node in self: 741 for chunk in node.iter_render(context): 742 yield chunk 719 if isinstance(node, Node): 720 bits.append(self.render_node(node, context)) 721 else: 722 bits.append(node) 723 return ''.join(bits) 743 724 744 725 def get_nodes_by_type(self, nodetype): … … 749 730 return nodes 750 731 732 def render_node(self, node, context): 733 return(node.render(context)) 734 751 735 class DebugNodeList(NodeList): 752 def iter_render(self, context): 753 for node in self: 754 if not isinstance(node, Node): 755 yield node 756 continue 757 try: 758 for chunk in node.iter_render(context): 759 yield chunk 760 except TemplateSyntaxError, e: 761 if not hasattr(e, 'source'): 762 e.source = node.source 763 raise 764 except Exception, e: 765 from sys import exc_info 766 wrapped = TemplateSyntaxError('Caught an exception while rendering: %s' % e) 767 wrapped.source = node.source 768 wrapped.exc_info = exc_info() 769 raise wrapped 736 def render_node(self, node, context): 737 try: 738 result = node.render(context) 739 except TemplateSyntaxError, e: 740 if not hasattr(e, 'source'): 741 e.source = node.source 742 raise 743 except Exception, e: 744 from sys import exc_info 745 wrapped = TemplateSyntaxError('Caught an exception while rendering: %s' % e) 746 wrapped.source = node.source 747 wrapped.exc_info = exc_info() 748 raise wrapped 749 return result 770 750 771 751 class TextNode(Node): … … 775 755 def __repr__(self): 776 756 return "<Text Node: '%s'>" % self.s[:25] 777 778 def iter_render(self, context):779 return (self.s,)780 757 781 758 def render(self, context): … … 801 778 else: 802 779 return output 803 804 def iter_render(self, context):805 return (self.render(context),)806 780 807 781 def render(self, context): … … 893 867 self.vars_to_resolve = vars_to_resolve 894 868 895 #def iter_render(self, context):896 # return (self.render(context),)897 898 869 def render(self, context): 899 870 resolved_vars = [resolve_variable(var, context) for var in self.vars_to_resolve] … … 918 889 self.vars_to_resolve = vars_to_resolve 919 890 920 def iter_render(self, context):891 def render(self, context): 921 892 resolved_vars = [resolve_variable(var, context) for var in self.vars_to_resolve] 922 893 if takes_context: … … 934 905 t = get_template(file_name) 935 906 self.nodelist = t.nodelist 936 return self.nodelist. iter_render(context_class(dict))907 return self.nodelist.render(context_class(dict)) 937 908 938 909 compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode) django/branches/boulder-oracle-sprint/django/template/loader.py
r5491 r5512 88 88 return Template(source, origin, name) 89 89 90 def _render_setup(template_name, dictionary=None, context_instance=None):90 def render_to_string(template_name, dictionary=None, context_instance=None): 91 91 """ 92 Common setup code for render_to_string and render_to_iter. 92 Loads the given template_name and renders it with the given dictionary as 93 context. The template_name may be a string to load a single template using 94 get_template, or it may be a tuple to use select_template to find one of 95 the templates in the list. Returns a string. 93 96 """ 94 if dictionary is None: 95 dictionary = {} 97 dictionary = dictionary or {} 96 98 if isinstance(template_name, (list, tuple)): 97 99 t = select_template(template_name) … … 102 104 else: 103 105 context_instance = Context(dictionary) 104 return t, context_instance 105 106 def render_to_string(template_name, dictionary=None, context_instance=None): 107 """ 108 Loads the given template_name and renders it with the given dictionary as 109 context. The template_name may be a string to load a single template using 110 get_template, or it may be a tuple to use select_template to find one of 111 the templates in the list. Returns a string. 112 """ 113 t, c = _render_setup(template_name, dictionary=dictionary, context_instance=context_instance) 114 return t.render(c) 115 116 def render_to_iter(template_name, dictionary=None, context_instance=None): 117 """ 118 Loads the given template_name and renders it with the given dictionary as 119 context. The template_name may be a string to load a single template using 120 get_template, or it may be a tuple to use select_template to find one of 121 the templates in the list. Returns a string. 122 """ 123 t, c = _render_setup(template_name, dictionary=dictionary, context_instance=context_instance) 124 return t.iter_render(c) 125 106 return t.render(context_instance) 126 107 127 108 def select_template(template_name_list): django/branches/boulder-oracle-sprint/django/template/loader_tags.py
r5491 r5512 16 16 return "<Block Node: %s. Contents: %r>" % (self.name, self.nodelist) 17 17 18 def iter_render(self, context):18 def render(self, context): 19 19 context.push() 20 20 # Save context in case of block.super(). 21 21 self.context = context 22 22 context['block'] = self 23 for chunk in self.nodelist.iter_render(context): 24 yield chunk 23 result = self.nodelist.render(context) 25 24 context.pop() 25 return result 26 26 27 27 def super(self): … … 60 60 return get_template_from_string(source, origin, parent) 61 61 62 def iter_render(self, context):62 def render(self, context): 63 63 compiled_parent = self.get_parent(context) 64 64 parent_is_child = isinstance(compiled_parent.nodelist[0], ExtendsNode) … … 80 80 parent_block.add_parent(parent_block.nodelist) 81 81 parent_block.nodelist = block_node.nodelist 82 return compiled_parent. iter_render(context)82 return compiled_parent.render(context) 83 83 84 84 class ConstantIncludeNode(Node): … … 92 92 self.template = None 93 93 94 def iter_render(self, context):94 def render(self, context): 95 95 if self.template: 96 return self.template.iter_render(context) 97 return () 96 return self.template.render(context) 97 else: 98 return '' 98 99 99 100 class IncludeNode(Node): … … 101 102 self.template_name = template_name 102 103 103 def iter_render(self, context):104 def render(self, context): 104 105 try: 105 106 template_name = resolve_variable(self.template_name, context) 106 107 t = get_template(template_name) 107 return t. iter_render(context)108 return t.render(context) 108 109 except TemplateSyntaxError, e: 109 110 if settings.TEMPLATE_DEBUG: 110 111 raise 111 return ()112 return '' 112 113 except: 113 return ()# Fail silently for invalid included templates.114 return '' # Fail silently for invalid included templates. 114 115 115 116 def do_block(parser, token):
