Django

Code

Show
Ignore:
Timestamp:
06/22/07 11:56:04 (1 year ago)
Author:
bouldersprinters
Message:

boulder-oracle-sprint: Merged to [5511]

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/branches/boulder-oracle-sprint/django/contrib/admin/templatetags/adminapplist.py

    r5491 r5512  
    88        self.varname = varname 
    99 
    10     def iter_render(self, context): 
     10    def render(self, context): 
    1111        from django.db import models 
    1212        from django.utils.text import capfirst 
    …… 
    5555                    }) 
    5656        context[self.varname] = app_list 
    57         return () 
     57        return '' 
    5858 
    5959def get_admin_app_list(parser, token): 

  • django/branches/boulder-oracle-sprint/django/contrib/admin/templatetags/admin_modify.py

    r5491 r5512  
    9595    get_nodelist = classmethod(get_nodelist) 
    9696 
    97     def iter_render(self, context): 
     97    def render(self, context): 
    9898        bound_field = template.resolve_variable(self.bound_field_var, context) 
    9999 
    …… 
    101101        context['bound_field'] = bound_field 
    102102 
    103         for chunk in self.get_nodelist(bound_field.field.__class__).iter_render(context): 
    104             yield chunk 
     103        output = self.get_nodelist(bound_field.field.__class__).render(context) 
    105104        context.pop() 
     105        return output 
    106106 
    107107class FieldWrapper(object): 
    …… 
    158158        self.rel_var = rel_var 
    159159 
    160     def iter_render(self, context): 
     160    def render(self, context): 
    161161        relation = template.resolve_variable(self.rel_var, context) 
    162162        context.push() 
    …… 
    170170        bound_related_object = relation.bind(context['form'], original, bound_related_object_class) 
    171171        context['bound_related_object'] = bound_related_object 
    172         for chunk in loader.get_template(bound_related_object.template_name()).iter_render(context): 
    173             yield chunk 
     172        t = loader.get_template(bound_related_object.template_name()) 
     173        output = t.render(context) 
    174174        context.pop() 
     175        return output 
    175176 
    176177def output_all(form_fields): 

  • django/branches/boulder-oracle-sprint/django/contrib/admin/templatetags/log.py

    r5491 r5512  
    1111        return "<GetAdminLog Node>" 
    1212 
    13     def iter_render(self, context): 
     13    def render(self, context): 
    1414        if self.user is None: 
    1515            context[self.varname] = LogEntry.objects.all().select_related()[:self.limit] 
    …… 
    1818                self.user = context[self.user].id 
    1919            context[self.varname] = LogEntry.objects.filter(user__id__exact=self.user).select_related()[:self.limit] 
    20         return () 
     20        return '' 
    2121 
    2222class DoGetAdminLog: 

  • django/branches/boulder-oracle-sprint/django/contrib/comments/templatetags/comments.py

    r5491 r5512  
    2525        self.is_public = is_public 
    2626 
    27     def iter_render(self, context): 
     27    def render(self, context): 
    2828        from django.conf import settings 
    2929        from django.utils.text import normalize_newlines 
    …… 
    3434                self.obj_id = template.resolve_variable(self.obj_id_lookup_var, context) 
    3535            except template.VariableDoesNotExist: 
    36                 return 
     36                return '' 
    3737            # Validate that this object ID is valid for this content-type. 
    3838            # We only have to do this validation if obj_id_lookup_var is provided, 
    …… 
    6868            context['logout_url'] = settings.LOGOUT_URL 
    6969            default_form = loader.get_template(COMMENT_FORM) 
    70         for chunk in default_form.iter_render(context): 
    71             yield chunk 
     70        output = default_form.render(context) 
    7271        context.pop() 
     72        return output 
    7373 
    7474class CommentCountNode(template.Node): 
    …… 
    7878        self.var_name, self.free = var_name, free 
    7979 
    80     def iter_render(self, context): 
     80    def render(self, context): 
    8181        from django.conf import settings 
    8282        manager = self.free and FreeComment.objects or Comment.objects 
    …… 
    8787            content_type__model__exact=self.module, site__id__exact=settings.SITE_ID).count() 
    8888        context[self.var_name] = comment_count 
    89         return () 
     89        return '' 
    9090 
    9191class CommentListNode(template.Node): 
    …… 
    9797        self.extra_kwargs = extra_kwargs or {} 
    9898 
    99     def iter_render(self, context): 
     99    def render(self, context): 
    100100        from django.conf import settings 
    101101        get_list_function = self.free and FreeComment.objects.filter or Comment.objects.get_list_with_karma 
    …… 
    104104                self.obj_id = template.resolve_variable(self.context_var_name, context) 
    105105            except template.VariableDoesNotExist: 
    106                 return () 
     106                return '' 
    107107        kwargs = { 
    108108            'object_id__exact': self.obj_id, 
    …… 
    128128 
    129129        context[self.var_name] = comment_list 
    130         return () 
     130        return '' 
    131131 
    132132class DoCommentForm: 

  • django/branches/boulder-oracle-sprint/django/core/servers/basehttp.py

    r5509 r5512  
    310310        if not self.result_is_file() and not self.sendfile(): 
    311311            for data in self.result: 
    312                 self.write(data, False) 
     312                self.write(data) 
    313313            self.finish_content() 
    314314        self.close() 
    …… 
    378378            self._write('Status: %s\r\n' % self.status) 
    379379 
    380     def write(self, data, flush=True): 
     380    def write(self, data): 
    381381        """'write()' callable as specified by PEP 333""" 
    382382 
    …… 
    395395        # XXX check Content-Length and truncate if too many bytes written? 
    396396        self._write(data) 
    397         if flush: 
    398             self._flush() 
     397        self._flush() 
    399398 
    400399    def sendfile(self): 
    …… 
    423422            self.headers['Content-Length'] = "0" 
    424423            self.send_headers() 
     424        else: 
     425            pass # XXX check if content-length was too short? 
    425426 
    426427    def close(self): 

  • django/branches/boulder-oracle-sprint/django/http/__init__.py

    r5491 r5512  
    223223        if isinstance(content, unicode): 
    224224            content = content.encode(self._charset) 
    225  
    226         # If self._container was an iterator, we have just exhausted it, so we 
    227         # need to save the results for anything else that needs access 
    228         if not self._is_string: 
    229             self._container = [content] 
    230             self._is_string = True 
    231225        return content 
    232226 
    …… 
    238232 
    239233    def __iter__(self): 
    240         for chunk in self._container: 
    241             if isinstance(chunk, unicode): 
    242                 chunk = chunk.encode(self._charset) 
    243             yield chunk 
     234        self._iterator = self._container.__iter__() 
     235        return self 
     236 
     237    def next(self): 
     238        chunk = self._iterator.next() 
     239        if isinstance(chunk, unicode): 
     240            chunk = chunk.encode(self._charset) 
     241        return chunk 
    244242 
    245243    def close(self): 

  • django/branches/boulder-oracle-sprint/django/oldforms/__init__.py

    r5491 r5512  
    309309        return data 
    310310    html2python = staticmethod(html2python) 
    311  
    312     def iter_render(self, data): 
    313         # this even needed? 
    314         return (self.render(data),) 
    315311 
    316312    def render(self, data): 

  • django/branches/boulder-oracle-sprint/django/shortcuts/__init__.py

    r5491 r5512  
    88 
    99def render_to_response(*args, **kwargs): 
    10     return HttpResponse(loader.render_to_iter(*args, **kwargs)) 
     10    return HttpResponse(loader.render_to_string(*args, **kwargs)) 
    1111load_and_render = render_to_response # For backwards compatibility. 
    1212 

  • django/branches/boulder-oracle-sprint/django/template/defaulttags.py

    r5491 r5512  
    1616            yield data[index] 
    1717 
     18 
    1819register = Library() 
    1920 
    2021class CommentNode(Node): 
    21     def iter_render(self, context): 
    22         return () 
     22    def render(self, context): 
     23        return '' 
    2324 
    2425class CycleNode(Node): 
    …… 
    2930        self.variable_name = variable_name 
    3031 
    31     def iter_render(self, context): 
    32         return (self.render(context),) 
    33  
    3432    def render(self, context): 
    3533        self.counter += 1 
    …… 
    4038 
    4139class DebugNode(Node): 
    42     def iter_render(self, context): 
     40    def render(self, context): 
    4341        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) 
    4846 
    4947class FilterNode(Node): 
    …… 
    5149        self.filter_expr, self.nodelist = filter_expr, nodelist 
    5250 
    53     def iter_render(self, context): 
     51    def render(self, context): 
    5452        output = self.nodelist.render(context) 
    5553        # apply filters 
    …… 
    5755        filtered = self.filter_expr.resolve(context) 
    5856        context.pop() 
    59         return (filtered,) 
     57        return filtered 
    6058 
    6159class FirstOfNode(Node): 
    6260    def __init__(self, vars): 
    6361        self.vars = vars 
    64  
    65     def iter_render(self, context): 
    66         return (self.render(context),) 
    6762 
    6863    def render(self, context): 
    …… 
    10196        return nodes 
    10297 
    103     def iter_render(self, context): 
     98    def render(self, context): 
     99        nodelist = NodeList() 
    104100        if 'forloop' in context: 
    105101            parentloop = context['forloop'] 
    …… 
    109105        try: 
    110106            values = self.sequence.resolve(context, True) 
    111             if values is None: 
    112                 values = () 
    113             elif not hasattr(values, '__len__'): 
    114                 values = list(values) 
    115107        except VariableDoesNotExist: 
    116             values = () 
     108            values = [] 
     109        if values is None: 
     110            values = [] 
     111        if not hasattr(values, '__len__'): 
     112            values = list(values) 
    117113        len_values = len(values) 
    118114        if self.reversed: 
    …… 
    133129            } 
    134130            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. 
    137132                context.update(dict(zip(self.loopvars, item))) 
    138133            else: 
    139134                context[self.loopvars[0]] = item 
    140  
    141             # We inline this to avoid the overhead since ForNode is pretty 
    142             # common. 
    143135            for node in self.nodelist_loop: 
    144                 for chunk in node.iter_render(context): 
    145                     yield chunk 
     136                nodelist.append(node.render(context)) 
    146137            if unpack: 
    147138                # The loop variables were pushed on to the context so pop them 
    …… 
    152143                context.pop() 
    153144        context.pop() 
     145        return nodelist.render(context) 
    154146 
    155147class IfChangedNode(Node): 
    …… 
    159151        self._varlist = varlist 
    160152 
    161     def iter_render(self, context): 
     153    def render(self, context): 
    162154        if 'forloop' in context and context['forloop']['first']: 
    163155            self._last_seen = None 
    …… 
    177169            context.push() 
    178170            context['ifchanged'] = {'firstloop': firstloop} 
    179             for chunk in self.nodelist.iter_render(context): 
    180                 yield chunk 
     171            content = self.nodelist.render(context) 
    181172            context.pop() 
     173            return content 
     174        else: 
     175            return '' 
    182176 
    183177class IfEqualNode(Node): 
    …… 
    190184        return "<IfEqualNode>" 
    191185 
    192     def iter_render(self, context): 
     186    def render(self, context): 
    193187        try: 
    194188            val1 = resolve_variable(self.var1, context) 
    …… 
    200194            val2 = None 
    201195        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) 
    204198 
    205199class IfNode(Node): 
    …… 
    226220        return nodes 
    227221 
    228     def iter_render(self, context): 
     222    def render(self, context): 
    229223        if self.link_type == IfNode.LinkTypes.or_: 
    230224            for ifnot, bool_expr in self.bool_exprs: 
    …… 
    234228                    value = None 
    235229                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) 
    238232        else: 
    239233            for ifnot, bool_expr in self.bool_exprs: 
    …… 
    243237                    value = None 
    244238                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) 
    247241 
    248242    class LinkTypes: 
    …… 
    255249        self.var_name = var_name 
    256250 
    257     def iter_render(self, context): 
     251    def render(self, context): 
    258252        obj_list = self.target.resolve(context, True) 
    259253        if obj_list == None: # target_var wasn't found in context; fail silently 
    260254            context[self.var_name] = [] 
    261             return () 
     255            return '' 
    262256        # List of dictionaries in the format 
    263257        # {'grouper': 'key', 'list': [list of contents]}. 
    264258        context[self.var_name] = [{'grouper':key, 'list':list(val)} for key, val in 
    265259            groupby(obj_list, lambda v, f=self.expression.resolve: f(v, True))] 
    266         return () 
     260        return '' 
    267261 
    268262def include_is_allowed(filepath): 
    …… 
    276270        self.filepath, self.parsed = filepath, parsed 
    277271 
    278     def iter_render(self, context): 
     272    def render(self, context): 
    279273        if not include_is_allowed(self.filepath): 
    280274            if settings.DEBUG: 
    281                 return ("[Didn't have permission to include file]",) 
     275                return "[Didn't have permission to include file]" 
    282276            else: 
    283277                return '' # Fail silently for invalid includes. 
    …… 
    290284        if self.parsed: 
    291285            try: 
    292                 return Template(output, name=self.filepath).iter_render(context) 
     286                t = Template(output, name=self.filepath) 
     287                return t.render(context) 
    293288            except TemplateSyntaxError, e: 
    294289                if settings.DEBUG: 
    …… 
    296291                else: 
    297292                    return '' # Fail silently for invalid included templates. 
    298         return (output,) 
     293        return output 
    299294 
    300295class LoadNode(Node): 
    301     def iter_render(self, context): 
    302         return () 
     296    def render(self, context): 
     297        return '' 
    303298 
    304299class NowNode(Node): 
    305300    def __init__(self, format_string): 
    306301        self.format_string = format_string 
    307  
    308     def iter_render(self, context): 
    309         return (self.render(context),) 
    310302 
    311303    def render(self, context): 
    …… 
    337329        self.tagtype = tagtype 
    338330 
    339     def iter_render(self, context): 
    340         return (self.render(context),) 
    341  
    342331    def render(self, context): 
    343332        return self.mapping.get(self.tagtype, '') 
    …… 
    349338        self.kwargs = kwargs 
    350339 
    351     def iter_render(self, context): 
     340    def render(self, context): 
    352341        from django.core.urlresolvers import reverse, NoReverseMatch 
    353342        args = [arg.resolve(context) for arg in self.args] 
    354343        kwargs = dict([(k, v.resolve(context)) for k, v in self.kwargs.items()]) 
    355344        try: 
    356             return (reverse(self.view_name, args=args, kwargs=kwargs),) 
     345            return reverse(self.view_name, args=args, kwargs=kwargs) 
    357346        except NoReverseMatch: 
    358347            try: 
    …… 
    360349                return reverse(project_name + '.' + self.view_name, args=args, kwargs=kwargs) 
    361350            except NoReverseMatch: 
    362                 return () 
     351                return '' 
    363352 
    364353class WidthRatioNode(Node): 
    …… 
    367356        self.max_expr = max_expr 
    368357        self.max_width = max_width 
    369  
    370     def iter_render(self, context): 
    371         return (self.render(context),) 
    372358 
    373359    def render(self, context): 
    …… 
    394380        return "<WithNode>" 
    395381 
    396     def iter_render(self, context): 
     382    def render(self, context): 
    397383        val = self.var.resolve(context) 
    398384        context.push() 
    399385        context[self.name] = val 
    400         for chunk in self.nodelist.iter_render(context): 
    401             yield chunk 
     386        output = self.nodelist.render(context) 
    402387        context.pop() 
     388        return output 
    403389 
    404390#@register.tag 

  • django/branches/boulder-oracle-sprint/django/template/__init__.py

    r5491 r5512  
    5656""" 
    5757import re 
    58 import types 
    5958from inspect import getargspec 
    6059from django.conf import settings 
    …… 
    169168                yield subnode 
    170169 
    171     def iter_render(self, context): 
     170    def render(self, context): 
    172171        "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) 
    177173 
    178174def compile_string(template_string, origin): 
    …… 
    700696    return current 
    701697 
    702 class NodeBase(type): 
    703     def __new__(cls, name, bases, attrs): 
    704         """ 
    705         Ensures that either a 'render' or 'render_iter' method is defined on 
    706         any Node sub-class. This avoids potential infinite loops at runtime. 
    707         """ 
    708         if not (isinstance(attrs.get('render'), types.FunctionType) or 
    709                 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  
    713698class Node(object): 
    714     __metaclass__ = NodeBase 
    715  
    716     def iter_render(self, context): 
    717         return (self.render(context),) 
    718  
    719699    def render(self, context): 
    720700        "Return the node rendered as a string" 
    721         return ''.join(self.iter_render(context)) 
     701        pass 
    722702 
    723703    def __iter__(self): 
    …… 
    735715class NodeList(list): 
    736716    def render(self, context): 
    737         return ''.join(self.iter_render(context)) 
    738  
    739     def iter_render(self, context): 
     717        bits = [] 
    740718        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) 
    743724 
    744725    def get_nodes_by_type(self, nodetype): 
    …… 
    749730        return nodes 
    750731 
     732    def render_node(self, node, context): 
     733        return(node.render(context)) 
     734 
    751735class 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 
    770750 
    771751class TextNode(Node): 
    …… 
    775755    def __repr__(self): 
    776756        return "<Text Node: '%s'>" % self.s[:25] 
    777  
    778     def iter_render(self, context): 
    779         return (self.s,) 
    780757 
    781758    def render(self, context): 
    …… 
    801778        else: 
    802779            return output 
    803  
    804     def iter_render(self, context): 
    805         return (self.render(context),) 
    806780 
    807781    def render(self, context): 
    …… 
    893867                self.vars_to_resolve = vars_to_resolve 
    894868 
    895             #def iter_render(self, context): 
    896             #    return (self.render(context),) 
    897  
    898869            def render(self, context): 
    899870                resolved_vars = [resolve_variable(var, context) for var in self.vars_to_resolve] 
    …… 
    918889                    self.vars_to_resolve = vars_to_resolve 
    919890 
    920                 def iter_render(self, context): 
     891                def render(self, context): 
    921892                    resolved_vars = [resolve_variable(var, context) for var in self.vars_to_resolve] 
    922893                    if takes_context: 
    …… 
    934905                            t = get_template(file_name) 
    935906                        self.nodelist = t.nodelist 
    936                     return self.nodelist.iter_render(context_class(dict)) 
     907                    return self.nodelist.render(context_class(dict)) 
    937908 
    938909            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  
    8888    return Template(source, origin, name) 
    8989 
    90 def _render_setup(template_name, dictionary=None, context_instance=None): 
     90def render_to_string(template_name, dictionary=None, context_instance=None): 
    9191    """ 
    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. 
    9396    """ 
    94     if dictionary is None: 
    95         dictionary = {} 
     97    dictionary = dictionary or {} 
    9698    if isinstance(template_name, (list, tuple)): 
    9799        t = select_template(template_name) 
    …… 
    102104    else: 
    103105        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) 
    126107 
    127108def select_template(template_name_list): 

  • django/branches/boulder-oracle-sprint/django/template/loader_tags.py

    r5491 r5512  
    1616        return "<Block Node: %s. Contents: %r>" % (self.name, self.nodelist) 
    1717 
    18     def iter_render(self, context): 
     18    def render(self, context): 
    1919        context.push() 
    2020        # Save context in case of block.super(). 
    2121        self.context = context 
    2222        context['block'] = self 
    23         for chunk in self.nodelist.iter_render(context): 
    24             yield chunk 
     23        result = self.nodelist.render(context) 
    2524        context.pop() 
     25        return result 
    2626 
    2727    def super(self): 
    …… 
    6060            return get_template_from_string(source, origin, parent) 
    6161 
    62     def iter_render(self, context): 
     62    def render(self, context): 
    6363        compiled_parent = self.get_parent(context) 
    6464        parent_is_child = isinstance(compiled_parent.nodelist[0], ExtendsNode) 
    …… 
    8080                parent_block.add_parent(parent_block.nodelist) 
    8181                parent_block.nodelist = block_node.nodelist 
    82         return compiled_parent.iter_render(context) 
     82        return compiled_parent.render(context) 
    8383 
    8484class ConstantIncludeNode(Node): 
    …… 
    9292            self.template = None 
    9393 
    94     def iter_render(self, context): 
     94    def render(self, context): 
    9595        if self.template: 
    96             return self.template.iter_render(context) 
    97         return () 
     96            return self.template.render(context) 
     97        else: 
     98            return '' 
    9899 
    99100class IncludeNode(Node): 
    …… 
    101102        self.template_name = template_name 
    102103 
    103     def iter_render(self, context): 
     104    def render(self, context): 
    104105        try: 
    105106            template_name = resolve_variable(self.template_name, context) 
    106107            t = get_template(template_name) 
    107             return t.iter_render(context) 
     108            return t.render(context) 
    108109        except TemplateSyntaxError, e: 
    109110            if settings.TEMPLATE_DEBUG: 
    110111                raise 
    111             return () 
     112            return '' 
    112113        except: 
    113             return () # Fail silently for invalid included templates. 
     114            return '' # Fail silently for invalid included templates. 
    114115 
    115116def do_block(parser, token): 

  • django/branches/boulder-oracle-sprint/django/test/utils.py

    r5491 r5512  
    1212 
    1313def instrumented_test_render(self, context): 
    14     """ 
    15     An instrumented Template render method, providing a signal that can be 
    16     intercepted by the test system Client. 
     14    """An instrumented Template render method, providing a signal  
     15    that can be intercepted by the test system Client 
     16     
    1717    """ 
    1818    dispatcher.send(signal=signals.template_rendered, sender=self, template=self, context=context) 
    1919    return self.nodelist.render(context) 
    20  
    21 def instrumented_test_iter_render(self, context): 
    22     """ 
    23     An instrumented Template iter_render method, providing a signal that can be 
    24     intercepted by the test system Client. 
    25     """ 
    26     for chunk in self.nodelist.iter_render(context): 
    27         yield chunk 
    28     dispatcher.send(signal=signals.template_rendered, sender=self, template=self, context=context) 
    2920     
    3021class TestSMTPConnection(object): 
    …… 
    5445    """ 
    5546    Template.original_render = Template.render 
    56     Template.original_iter_render = Template.iter_render 
    5747    Template.render = instrumented_test_render 
    58     Template.iter_render = instrumented_test_render 
    5948     
    6049    mail.original_SMTPConnection = mail.SMTPConnection 
    …… 
    7160    """ 
    7261    Template.render = Template.original_render 
    73     Template.iter_render = Template.original_iter_render 
    74     del Template.original_render, Template.original_iter_render 
     62    del Template.original_render 
    7563     
    7664    mail.SMTPConnection = mail.original_SMTPConnection 

  • django/branches/boulder-oracle-sprint/django/views/debug.py

    r5491 r5512  
    138138        'loader_debug_info': loader_debug_info, 
    139139    }) 
    140     return HttpResponseServerError(t.iter_render(c), mimetype='text/html') 
     140    return HttpResponseServerError(t.render(c), mimetype='text/html') 
    141141 
    142142def technical_404_response(request, exception): 
    …… 
    161161        'settings': get_safe_settings(), 
    162162    }) 
    163     return HttpResponseNotFound(t.iter_render(c), mimetype='text/html') 
     163    return HttpResponseNotFound(t.render(c), mimetype='text/html') 
    164164 
    165165def empty_urlconf(request): 
    …… 
    169169        'project_name': settings.SETTINGS_MODULE.split('.')[0] 
    170170    })&n