Django

Code

Changeset 867

Show
Ignore:
Timestamp:
10/14/05 15:10:13 (3 years ago)
Author:
adrian
Message:

Fixed #626 -- Moved template modules to django.core.template package. django.core.template_loader is deprecated, in favor of django.core.template.loader.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/trunk/django/core/extensions.py

    r673 r867  
    33# for convenience's sake. 
    44 
    5 from django.core import template_loader 
    65from django.core.exceptions import Http404, ObjectDoesNotExist 
    7 from django.core.template import Context 
     6from django.core.template import Context, loader 
    87from django.conf.settings import DEBUG, INTERNAL_IPS 
    98from django.utils.httpwrappers import HttpResponse 
    109 
    1110def render_to_response(*args, **kwargs): 
    12     return HttpResponse(template_loader.render_to_string(*args, **kwargs)) 
     11    return HttpResponse(loader.render_to_string(*args, **kwargs)) 
    1312load_and_render = render_to_response # For backwards compatibility. 
    1413 

  • django/trunk/django/core/rss.py

    r743 r867  
    1 from django.core import template_loader 
    21from django.core.exceptions import ObjectDoesNotExist 
    3 from django.core.template import Context 
     2from django.core.template import Context, loader 
    43from django.models.core import sites 
    54from django.utils import feedgenerator 
    …… 
    2928        get_list_kwargs_cb -- Function that takes the param and returns a 
    3029        dictionary to use in addition to get_list_kwargs (if applicable). 
    31          
     30 
    3231        get_pubdate_cb -- Function that takes the object and returns a datetime 
    3332        to use as the publication date in the feed. 
    …… 
    5049        self.enc_length = enc_length 
    5150        self.enc_mime_type = enc_mime_type 
    52          
     51 
    5352    def get_feed(self, param_slug=None): 
    5453        """ 
    …… 
    6564        current_site = sites.get_current() 
    6665        f = self._get_feed_generator_object(param) 
    67         title_template = template_loader.get_template('rss/%s_title' % self.slug) 
    68         description_template = template_loader.get_template('rss/%s_description' % self.slug) 
     66        title_template = loader.get_template('rss/%s_title' % self.slug) 
     67        description_template = loader.get_template('rss/%s_description' % self.slug) 
    6968        kwargs = self.get_list_kwargs.copy() 
    7069        if param and self.get_list_kwargs_cb: 
    …… 
    103102            ) 
    104103        return f 
    105          
     104 
    106105    def _get_feed_generator_object(self, param): 
    107106        current_site = sites.get_current() 

  • django/trunk/django/core/template/defaultfilters.py

    r859 r867  
    11"Default variable filters" 
    22 
    3 import template, re 
     3from django.core.template import register_filter, resolve_variable 
     4import re 
    45import random as random_module 
    56 
    …… 
    197198    the argument. 
    198199    """ 
    199     decorated = [(template.resolve_variable('var.' + arg, {'var' : item}), item) for item in value] 
     200    decorated = [(resolve_variable('var.' + arg, {'var' : item}), item) for item in value] 
    200201    decorated.sort() 
    201202    return [item[1] for item in decorated] 
    …… 
    206207    property given in the argument. 
    207208    """ 
    208     decorated = [(template.resolve_variable('var.' + arg, {'var' : item}), item) for item in value] 
     209    decorated = [(resolve_variable('var.' + arg, {'var' : item}), item) for item in value] 
    209210    decorated.sort() 
    210211    decorated.reverse() 
    …… 
    415416    return pformat(value) 
    416417 
    417 # Syntax: template.register_filter(name of filter, callback, has_argument) 
    418 template.register_filter('add', add, True) 
    419 template.register_filter('addslashes', addslashes, False) 
    420 template.register_filter('capfirst', capfirst, False) 
    421 template.register_filter('center', center, True) 
    422 template.register_filter('cut', cut, True) 
    423 template.register_filter('date', date, True) 
    424 template.register_filter('default', default, True) 
    425 template.register_filter('dictsort', dictsort, True) 
    426 template.register_filter('dictsortreversed', dictsortreversed, True) 
    427 template.register_filter('divisibleby', divisibleby, True) 
    428 template.register_filter('escape', escape, False) 
    429 template.register_filter('filesizeformat', filesizeformat, False) 
    430 template.register_filter('first', first, False) 
    431 template.register_filter('fix_ampersands', fix_ampersands, False) 
    432 template.register_filter('floatformat', floatformat, False) 
    433 template.register_filter('get_digit', get_digit, True) 
    434 template.register_filter('join', join, True) 
    435 template.register_filter('length', length, False) 
    436 template.register_filter('length_is', length_is, True) 
    437 template.register_filter('linebreaks', linebreaks, False) 
    438 template.register_filter('linebreaksbr', linebreaksbr, False) 
    439 template.register_filter('linenumbers', linenumbers, False) 
    440 template.register_filter('ljust', ljust, True) 
    441 template.register_filter('lower', lower, False) 
    442 template.register_filter('make_list', make_list, False) 
    443 template.register_filter('phone2numeric', phone2numeric, False) 
    444 template.register_filter('pluralize', pluralize, False) 
    445 template.register_filter('pprint', pprint, False) 
    446 template.register_filter('removetags', removetags, True) 
    447 template.register_filter('random', random, False) 
    448 template.register_filter('rjust', rjust, True) 
    449 template.register_filter('slice', slice_, True) 
    450 template.register_filter('slugify', slugify, False) 
    451 template.register_filter('stringformat', stringformat, True) 
    452 template.register_filter('striptags', striptags, False) 
    453 template.register_filter('time', time, True) 
    454 template.register_filter('timesince', timesince, False) 
    455 template.register_filter('title', title, False) 
    456 template.register_filter('truncatewords', truncatewords, True) 
    457 template.register_filter('unordered_list', unordered_list, False) 
    458 template.register_filter('upper', upper, False) 
    459 template.register_filter('urlencode', urlencode, False) 
    460 template.register_filter('urlize', urlize, False) 
    461 template.register_filter('urlizetrunc', urlizetrunc, True) 
    462 template.register_filter('wordcount', wordcount, False) 
    463 template.register_filter('wordwrap', wordwrap, True) 
    464 template.register_filter('yesno', yesno, True) 
     418# Syntax: register_filter(name of filter, callback, has_argument) 
     419register_filter('add', add, True) 
     420register_filter('addslashes', addslashes, False) 
     421register_filter('capfirst', capfirst, False) 
     422register_filter('center', center, True) 
     423register_filter('cut', cut, True) 
     424register_filter('date', date, True) 
     425register_filter('default', default, True) 
     426register_filter('dictsort', dictsort, True) 
     427register_filter('dictsortreversed', dictsortreversed, True) 
     428register_filter('divisibleby', divisibleby, True) 
     429register_filter('escape', escape, False) 
     430register_filter('filesizeformat', filesizeformat, False) 
     431register_filter('first', first, False) 
     432register_filter('fix_ampersands', fix_ampersands, False) 
     433register_filter('floatformat', floatformat, False) 
     434register_filter('get_digit', get_digit, True) 
     435register_filter('join', join, True) 
     436register_filter('length', length, False) 
     437register_filter('length_is', length_is, True) 
     438register_filter('linebreaks', linebreaks, False) 
     439register_filter('linebreaksbr', linebreaksbr, False) 
     440register_filter('linenumbers', linenumbers, False) 
     441register_filter('ljust', ljust, True) 
     442register_filter('lower', lower, False) 
     443register_filter('make_list', make_list, False) 
     444register_filter('phone2numeric', phone2numeric, False) 
     445register_filter('pluralize', pluralize, False) 
     446register_filter('pprint', pprint, False) 
     447register_filter('removetags', removetags, True) 
     448register_filter('random', random, False) 
     449register_filter('rjust', rjust, True) 
     450register_filter('slice', slice_, True) 
     451register_filter('slugify', slugify, False) 
     452register_filter('stringformat', stringformat, True) 
     453register_filter('striptags', striptags, False) 
     454register_filter('time', time, True) 
     455register_filter('timesince', timesince, False) 
     456register_filter('title', title, False) 
     457register_filter('truncatewords', truncatewords, True) 
     458register_filter('unordered_list', unordered_list, False) 
     459register_filter('upper', upper, False) 
     460register_filter('urlencode', urlencode, False) 
     461register_filter('urlize', urlize, False) 
     462register_filter('urlizetrunc', urlizetrunc, True) 
     463register_filter('wordcount', wordcount, False) 
     464register_filter('wordwrap', wordwrap, True) 
     465register_filter('yesno', yesno, True) 

  • django/trunk/django/core/template/defaulttags.py

    r736 r867  
    11"Default tags used by the template system, available to all templates." 
    22 
     3from django.core.template import Node, NodeList, Template, Context, resolve_variable, resolve_variable_with_filters, get_filters_from_token, registered_filters 
     4from django.core.template import TemplateSyntaxError, VariableDoesNotExist, BLOCK_TAG_START, BLOCK_TAG_END, VARIABLE_TAG_START, VARIABLE_TAG_END, register_tag 
    35import sys 
    4 import template 
    5  
    6 class CommentNode(template.Node): 
     6 
     7class CommentNode(Node): 
    78    def render(self, context): 
    89        return '' 
    910 
    10 class CycleNode(template.Node): 
     11class CycleNode(Node): 
    1112    def __init__(self, cyclevars): 
    1213        self.cyclevars = cyclevars 
    …… 
    1819        return self.cyclevars[self.counter % self.cyclevars_len] 
    1920 
    20 class DebugNode(template.Node): 
     21class DebugNode(Node): 
    2122    def render(self, context): 
    2223        from pprint import pformat 
    …… 
    2627        return ''.join(output) 
    2728 
    28 class FilterNode(template.Node): 
     29class FilterNode(Node): 
    2930    def __init__(self, filters, nodelist): 
    3031        self.filters, self.nodelist = filters, nodelist 
    …… 
    3435        # apply filters 
    3536        for f in self.filters: 
    36             output = template.registered_filters[f[0]][0](output, f[1]) 
     37            output = registered_filters[f[0]][0](output, f[1]) 
    3738        return output 
    3839 
    39 class FirstOfNode(template.Node): 
     40class FirstOfNode(Node): 
    4041    def __init__(self, vars): 
    4142        self.vars = vars 
    …… 
    4344    def render(self, context): 
    4445        for var in self.vars: 
    45             value = template.resolve_variable(var, context) 
     46            value = resolve_variable(var, context) 
    4647            if value: 
    4748                return str(value) 
    4849        return '' 
    4950 
    50 class ForNode(template.Node): 
     51class ForNode(Node): 
    5152    def __init__(self, loopvar, sequence, reversed, nodelist_loop): 
    5253        self.loopvar, self.sequence = loopvar, sequence 
    …… 
    7475 
    7576    def render(self, context): 
    76         nodelist = template.NodeList() 
     77        nodelist = NodeList() 
    7778        if context.has_key('forloop'): 
    7879            parentloop = context['forloop'] 
    …… 
    8182        context.push() 
    8283        try: 
    83             values = template.resolve_variable_with_filters(self.sequence, context) 
    84         except template.VariableDoesNotExist: 
     84            values = resolve_variable_with_filters(self.sequence, context) 
     85        except VariableDoesNotExist: 
    8586            values = [] 
    8687        if values is None: 
    …… 
    112113        return nodelist.render(context) 
    113114 
    114 class IfChangedNode(template.Node): 
     115class IfChangedNode(Node): 
    115116    def __init__(self, nodelist): 
    116117        self.nodelist = nodelist 
    …… 
    130131            return '' 
    131132 
    132 class IfEqualNode(template.Node): 
     133class IfEqualNode(Node): 
    133134    def __init__(self, var1, var2, nodelist_true, nodelist_false, negate): 
    134135        self.var1, self.var2 = var1, var2 
    …… 
    140141 
    141142    def render(self, context): 
    142         val1 = template.resolve_variable(self.var1, context) 
    143         val2 = template.resolve_variable(self.var2, context) 
     143        val1 = resolve_variable(self.var1, context) 
     144        val2 = resolve_variable(self.var2, context) 
    144145        if (self.negate and val1 != val2) or (not self.negate and val1 == val2): 
    145146            return self.nodelist_true.render(context) 
    146147        return self.nodelist_false.render(context) 
    147148 
    148 class IfNode(template.Node): 
     149class IfNode(Node): 
    149150    def __init__(self, boolvars, nodelist_true, nodelist_false): 
    150151        self.boolvars = boolvars 
    …… 
    171172        for ifnot, boolvar in self.boolvars: 
    172173            try: 
    173                 value = template.resolve_variable_with_filters(boolvar, context) 
    174             except template.VariableDoesNotExist: 
     174                value = resolve_variable_with_filters(boolvar, context) 
     175            except VariableDoesNotExist: 
    175176                value = None 
    176177            if (value and not ifnot) or (ifnot and not value): 
    …… 
    178179        return self.nodelist_false.render(context) 
    179180 
    180 class RegroupNode(template.Node): 
     181class RegroupNode(Node): 
    181182    def __init__(self, target_var, expression, var_name): 
    182183        self.target_var, self.expression = target_var, expression 
    …… 
    184185 
    185186    def render(self, context): 
    186         obj_list = template.resolve_variable_with_filters(self.target_var, context) 
     187        obj_list = resolve_variable_with_filters(self.target_var, context) 
    187188        if obj_list == '': # target_var wasn't found in context; fail silently 
    188189            context[self.var_name] = [] 
    …… 
    190191        output = [] # list of dictionaries in the format {'grouper': 'key', 'list': [list of contents]} 
    191192        for obj in obj_list: 
    192             grouper = template.resolve_variable_with_filters('var.%s' % self.expression, \ 
    193                 template.Context({'var': obj})) 
     193            grouper = resolve_variable_with_filters('var.%s' % self.expression, \ 
     194                Context({'var': obj})) 
    194195            if output and repr(output[-1]['grouper']) == repr(grouper): 
    195196                output[-1]['list'].append(obj) 
    …… 
    206207    return False 
    207208 
    208 class SsiNode(template.Node): 
     209class SsiNode(Node): 
    209210    def __init__(self, filepath, parsed): 
    210211        self.filepath, self.parsed = filepath, parsed 
    …… 
    221222        if self.parsed: 
    222223            try: 
    223                 t = template.Template(output) 
     224                t = Template(output) 
    224225                return t.render(context) 
    225             except template.TemplateSyntaxError: 
     226            except TemplateSyntaxError: 
    226227                return '' # Fail silently for invalid included templates. 
    227228        return output 
    228229 
    229 class LoadNode(template.Node): 
     230class LoadNode(Node): 
    230231    def __init__(self, taglib): 
    231232        self.taglib = taglib 
    …… 
    245246        return '' 
    246247 
    247 class NowNode(template.Node): 
     248class NowNode(Node): 
    248249    def __init__(self, format_string): 
    249250        self.format_string = format_string 
    …… 
    255256        return df.format(self.format_string) 
    256257 
    257 class TemplateTagNode(template.Node): 
    258     mapping = {'openblock': template.BLOCK_TAG_START, 
    259                'closeblock': template.BLOCK_TAG_END, 
    260                'openvariable': template.VARIABLE_TAG_START, 
    261                'closevariable': template.VARIABLE_TAG_END} 
     258class TemplateTagNode(Node): 
     259    mapping = {'openblock': BLOCK_TAG_START, 
     260               'closeblock': BLOCK_TAG_END, 
     261               'openvariable': VARIABLE_TAG_START, 
     262               'closevariable': VARIABLE_TAG_END} 
    262263 
    263264    def __init__(self, tagtype): 
    …… 
    267268        return self.mapping.get(self.tagtype, '') 
    268269 
    269 class WidthRatioNode(template.Node): 
     270class WidthRatioNode(Node): 
    270271    def __init__(self, val_var, max_var, max_width): 
    271272        self.val_var = val_var 
    …… 
    275276    def render(self, context): 
    276277        try: 
    277             value = template.resolve_variable_with_filters(self.val_var, context) 
    278             maxvalue = template.resolve_variable_with_filters(self.max_var, context) 
    279         except template.VariableDoesNotExist: 
     278            value = resolve_variable_with_filters(self.val_var, context) 
     279            maxvalue = resolve_variable_with_filters(self.max_var, context) 
     280        except VariableDoesNotExist: 
    280281            return '' 
    281282        try: 
    …… 
    331332    args = token.contents.split() 
    332333    if len(args) < 2: 
    333         raise template.TemplateSyntaxError("'Cycle' statement requires at least two arguments") 
     334        raise TemplateSyntaxError("'Cycle' statement requires at least two arguments") 
    334335 
    335336    elif len(args) == 2 and "," in args[1]: 
    …… 
    342343        name = args[1] 
    343344        if not parser._namedCycleNodes.has_key(name): 
    344             raise template.TemplateSyntaxError("Named cycle '%s' does not exist" % name) 
     345            raise TemplateSyntaxError("Named cycle '%s' does not exist" % name) 
    345346        return parser._namedCycleNodes[name] 
    346347 
    …… 
    348349        # {% cycle a,b,c as name %} 
    349350        if args[2] != 'as': 
    350             raise template.TemplateSyntaxError("Second 'cycle' argument must be 'as'") 
     351            raise TemplateSyntaxError("Second 'cycle' argument must be 'as'") 
    351352        cyclevars = [v for v in args[1].split(",") if v]    # split and kill blanks 
    352353        name = args[3] 
    …… 
    360361 
    361362    else: 
    362         raise template.TemplateSyntaxError("Invalid arguments to 'cycle': %s" % args) 
     363        raise TemplateSyntaxError("Invalid arguments to 'cycle': %s" % args) 
    363364 
    364365def do_debug(parser, token): 
    …… 
    380381    """ 
    381382    _, rest = token.contents.split(None, 1) 
    382     _, filters = template.get_filters_from_token('var|%s' % rest) 
     383    _, filters = get_filters_from_token('var|%s' % rest) 
    383384    nodelist = parser.parse(('endfilter',)) 
    384385    parser.delete_first_token() 
    …… 
    409410    bits = token.contents.split()[1:] 
    410411    if len(bits) < 1: 
    411         raise template.TemplateSyntaxError, "'firstof' statement requires at least one argument" 
     412        raise TemplateSyntaxError, "'firstof' statement requires at least one argument" 
    412413    return FirstOfNode(bits) 
    413414 
    …… 
    435436        ``forloop.counter``         The current iteration of the loop (1-indexed) 
    436437        ``forloop.counter0``        The current iteration of the loop (0-indexed) 
    437         ``forloop.revcounter``      The number of iterations from the end of the  
     438        ``forloop.revcounter``      The number of iterations from the end of the 
    438439                                    loop (1-indexed) 
    439         ``forloop.revcounter0``     The number of iterations from the end of the  
     440        ``forloop.revcounter0``     The number of iterations from the end of the 
    440441                                    loop (0-indexed) 
    441442        ``forloop.first``           True if this is the first time through the loop 
    …… 
    448449    bits = token.contents.split() 
    449450    if len(bits) == 5 and bits[4] != 'reversed': 
    450         raise template.TemplateSyntaxError, "'for' statements with five words should end in 'reversed': %s" % token.contents 
     451        raise TemplateSyntaxError, "'for' statements with five words should end in 'reversed': %s" % token.contents 
    451452    if len(bits) not in (4, 5): 
    452         raise template.TemplateSyntaxError, "'for' statements should have either four or five words: %s" % token.contents 
     453        raise TemplateSyntaxError, "'for' statements should have either four or five words: %s" % token.contents 
    453454    if bits[2] != 'in': 
    454         raise template.TemplateSyntaxError, "'for' statement must contain 'in' as the second word: %s" % token.contents 
     455        raise TemplateSyntaxError, "'for' statement must contain 'in' as the second word: %s" % token.contents 
    455456    loopvar = bits[1] 
    456457    sequence = bits[3] 
    …… 
    478479    bits = token.contents.split() 
    479480    if len(bits) != 3: 
    480         raise template.TemplateSyntaxError, "%r takes two arguments" % bits[0] 
     481        raise TemplateSyntaxError, "%r takes two arguments" % bits[0] 
    481482    end_tag = 'end' + bits[0] 
    482483    nodelist_true = parser.parse(('else', end_tag)) 
    …… 
    486487        parser.delete_first_token() 
    487488    else: 
    488         nodelist_false = template.NodeList() 
     489        nodelist_false = NodeList() 
    489490    return IfEqualNode(bits[1], bits[2], nodelist_true, nodelist_false, negate) 
    490491 
    …… 
    539540    del bits[0] 
    540541    if not bits: 
    541         raise template.TemplateSyntaxError, "'if' statement requires at least one argument" 
     542        raise TemplateSyntaxError, "'if' statement requires at least one argument" 
    542543    # bits now looks something like this: ['a', 'or', 'not', 'b', 'or', 'c.d'] 
    543544    boolpairs = ' '.join(bits).split(' or ') 
    …… 
    547548            not_, boolvar = boolpair.split() 
    548549            if not_ != 'not': 
    549                 raise template.TemplateSyntaxError, "Expected 'not' in if statement" 
     550                raise TemplateSyntaxError, "Expected 'not' in if statement" 
    550551            boolvars.append((True, boolvar)) 
    551552        else: 
    …… 
    557558        parser.delete_first_token() 
    558559    else: 
    559         nodelist_false = template.NodeList() 
     560        nodelist_false = NodeList() 
    560561    return IfNode(boolvars, nodelist_true, nodelist_false) 
    561562 
    …… 
    577578    bits = token.contents.split() 
    578579    if len(bits) != 1: 
    579         raise template.TemplateSyntaxError, "'ifchanged' tag takes no arguments" 
     580        raise TemplateSyntaxError, "'ifchanged' tag takes no arguments" 
    580581    nodelist = parser.parse(('endifchanged',)) 
    581582    parser.delete_first_token() 
    …… 
    600601    parsed = False 
    601602    if len(bits) not in (2, 3): 
    602         raise template.TemplateSyntaxError, "'ssi' tag takes one argument: the path to the file to be included" 
     603        raise TemplateSyntaxError, "'ssi' tag takes one argument: the path to the file to be included" 
    603604    if len(bits) == 3: 
    604605        if bits[2] == 'parsed': 
    605606            parsed = True 
    606607        else: 
    607             raise template.TemplateSyntaxError, "Second (optional) argument to %s tag must be 'parsed'" % bits[0] 
     608            raise TemplateSyntaxError, "Second (optional) argument to %s tag must be 'parsed'" % bits[0] 
    608609    return SsiNode(bits[1], parsed) 
    609610 
    …… 
    618619    bits = token.contents.split() 
    619620    if len(bits) != 2: 
    620         raise template.TemplateSyntaxError, "'load' statement takes one argument" 
     621        raise TemplateSyntaxError, "'load' statement takes one argument" 
    621622    taglib = bits[1] 
    622623    # check at compile time that the module can be imported 
    …… 
    624625        LoadNode.load_taglib(taglib) 
    625626    except ImportError: 
    626         raise template.TemplateSyntaxError, "'%s' is not a valid tag library" % taglib 
     627        raise TemplateSyntaxError, "'%s' is not a valid tag library" % taglib 
    627628    return LoadNode(taglib) 
    628629 
    …… 
    640641    bits = token.contents.split('"') 
    641642    if len(bits) != 3: 
    642         raise template.TemplateSyntaxError, "'now' statement takes one argument" 
     643        raise TemplateSyntaxError, "'now' statement takes one argument" 
    643644    format_string = bits[1] 
    644645    return NowNode(format_string) 
    …… 
    692693    firstbits = token.contents.split(None, 3) 
    693694    if len(firstbits) != 4: 
    694         raise template.TemplateSyntaxError, "'regroup' tag takes five arguments" 
     695        raise TemplateSyntaxError, "'regroup' tag takes five arguments" 
    695696    target_var = firstbits[1] 
    696697    if firstbits[2] != 'by': 
    697         raise template.TemplateSyntaxError, "second argument to 'regroup' tag must be 'by'" 
     698        raise TemplateSyntaxError, "second argument to 'regroup' tag must be 'by'" 
    698699    lastbits_reversed = firstbits[3][::-1].split(None, 2) 
    699700    if lastbits_reversed[1][::-1] != 'as': 
    700         raise template.TemplateSyntaxError, "next-to-last argument to 'regroup' tag must be 'as'" 
     701        raise TemplateSyntaxError, "next-to-last argument to 'regroup' tag must be 'as'" 
    701702    expression = lastbits_reversed[2][::-1] 
    702703    var_name = lastbits_reversed[0][::-1] 
    …… 
    723724    bits = token.contents.split() 
    724725    if len(bits) != 2: 
    725         raise template.TemplateSyntaxError, "'templatetag' statement takes one argument" 
     726        raise TemplateSyntaxError, "'templatetag' statement takes one argument" 
    726727    tag = bits[1] 
    727728    if not TemplateTagNode.mapping.has_key(tag): 
    728         raise template.TemplateSyntaxError, "Invalid templatetag argument: '%s'. Must be one of: %s" % \ 
     729        raise TemplateSyntaxError, "Invalid templatetag argument: '%s'. Must be one of: %s" % \ 
    729730            (tag, TemplateTagNode.mapping.keys()) 
    730731    return TemplateTagNode(tag) 
    …… 
    745746    bits = token.contents.split() 
    746747    if len(bits) != 4: 
    747         raise template.TemplateSyntaxError("widthratio takes three arguments") 
     748        raise TemplateSyntaxError("widthratio takes three arguments") 
    748749    tag, this_value_var, max_value_var, max_width = bits 
    749750    try: 
    750751        max_width = int(max_width) 
    751752    except ValueError: 
    752         raise template.TemplateSyntaxError("widthratio final argument must be an integer") 
     753        raise TemplateSyntaxError("widthratio final argument must be an integer") 
    753754    return WidthRatioNode(this_value_var, max_value_var, max_width) 
    754755 
    755 template.register_tag('comment', do_comment) 
    756 template.register_tag('cycle', do_cycle) 
    757 template.register_tag('debug', do_debug) 
    758 template.register_tag('filter', do_filter) 
    759 template.register_tag('firstof', do_firstof) 
    760 template.register_tag('for', do_for) 
    761 template.register_tag('ifequal', lambda parser, token: do_ifequal(parser, token, False)) 
    762 template.register_tag('ifnotequal', lambda parser, token: do_ifequal(parser, token, True)) 
    763 template.register_tag('if', do_if) 
    764 template.register_tag('ifchanged', do_ifchanged) 
    765 template.register_tag('regroup', do_regroup) 
    766 template.register_tag('ssi', do_ssi) 
    767 template.register_tag('load', do_load) 
    768 template.register_tag('now', do_now) 
    769 template.register_tag('templatetag', do_templatetag) 
    770 template.register_tag('widthratio', do_widthratio) 
     756register_tag('comment', do_comment) 
     757register_tag('cycle', do_cycle) 
     758register_tag('debug', do_debug) 
     759register_tag('filter', do_filter) 
     760register_tag('firstof', do_firstof) 
     761register_tag('for', do_for) 
     762register_tag('ifequal', lambda parser, token: do_ifequal(parser, token, False)) 
     763register_tag('ifnotequal', lambda parser, token: do_ifequal(parser, token, True)) 
     764register_tag('if', do_if) 
     765register_tag('ifchanged', do_ifchanged) 
     766register_tag('regroup', do_regroup) 
     767register_tag('ssi', do_ssi) 
     768register_tag('load', do_load) 
     769register_tag('now', do_now) 
     770register_tag('templatetag', do_templatetag) 
     771register_tag('widthratio', do_widthratio) 

  • django/trunk/django/core/template_loader.py

    r717 r867  
    1 "Wrapper for loading templates from storage of some sort (e.g. files or db)" 
    2 import template 
    3 from template_file import load_template_source 
     1# This module is DEPRECATED! 
     2# 
     3# You should no longer be using django.core.template_loader. 
     4# 
     5# Use django.core.template.loader instead. 
    46 
    5 class ExtendsError(Exception): 
    6     pass 
    7  
    8 def get_template(template_name): 
    9     """ 
    10     Returns a compiled template.Template object for the given template name, 
    11     handling template inheritance recursively. 
    12     """ 
    13     return get_template_from_string(load_template_source(template_name)) 
    14  
    15 def get_template_from_string(source): 
    16     """ 
    17     Returns a compiled template.Template object for the given template code, 
    18     handling template inheritance recursively. 
    19     """ 
    20     return template.Template(source) 
    21  
    22 def render_to_string(template_name, dictionary=None, context_instance=None): 
    23     """ 
    24     Loads the given template_name and renders it with the given dictionary as 
    25     context. The template_name may be a string to load a single template using 
    26     get_template, or it may be a tuple to use select_template to find one of 
    27     the templates in the list.  Returns a string.  
    28     """ 
    29     dictionary = dictionary or {} 
    30     if isinstance(template_name, (list, tuple)): 
    31         t = select_template(template_name) 
    32     else: 
    33         t = get_template(template_name) 
    34     if context_instance: 
    35         context_instance.update(dictionary) 
    36     else: 
    37         context_instance = template.Context(dictionary) 
    38     return t.render(context_instance) 
    39  
    40 def select_template(template_name_list): 
    41     "Given a list of template names, returns the first that can be loaded." 
    42     for template_name in template_name_list: 
    43         try: 
    44             return get_template(template_name) 
    45         except template.TemplateDoesNotExist: 
    46             continue 
    47     # If we get here, none of the templates could be loaded 
    48     raise template.TemplateDoesNotExist, ', '.join(template_name_list) 
    49  
    50 class BlockNode(template.Node): 
    51     def __init__(self, name, nodelist, parent=None): 
    52         self.name, self.nodelist, self.parent = name, nodelist, parent 
    53  
    54     def __repr__(self): 
    55         return "<Block Node: %s. Contents: %r>" % (self.name, self.nodelist) 
    56  
    57     def render(self, context): 
    58         context.push() 
    59         # Save context in case of block.super(). 
    60         self.context = context 
    61         context['block'] = self 
    62         result = self.nodelist.render(context) 
    63         context.pop() 
    64         return result 
    65  
    66     def super(self): 
    67         if self.parent: 
    68             return self.parent.render(self.context) 
    69         return '' 
    70  
    71     def add_parent(self, nodelist): 
    72         if self.parent: 
    73             self.parent.add_parent(nodelist) 
    74         else: 
    75             self.parent = BlockNode(self.name, nodelist) 
    76  
    77 class ExtendsNode(template.Node): 
    78     def __init__(self, nodelist, parent_name, parent_name_var, template_dirs=None): 
    79         self.nodelist = nodelist 
    80         self.parent_name, self.parent_name_var = parent_name, parent_name_var 
    81         self.template_dirs = template_dirs 
    82  
    83     def get_parent(self, context): 
    84         if self.parent_name_var: 
    85             self.parent_name = template.resolve_variable_with_filters(self.parent_name_var, context) 
    86         parent = self.parent_name 
    87         if not parent: 
    88             error_msg = "Invalid template name in 'extends' tag: %r." % parent 
    89             if self.parent_name_var: 
    90                 error_msg += " Got this from the %r variable." % self.parent_name_var 
    91             raise template.TemplateSyntaxError, error_msg 
    92         try: 
    93             return get_template_from_string(load_template_source(parent, self.template_dirs)) 
    94         except template.TemplateDoesNotExist: 
    95             raise template.TemplateSyntaxError, "Template %r cannot be extended, because it doesn't exist" % parent 
    96  
    97     def render(self, context): 
    98         compiled_parent = self.get_parent(context) 
    99         parent_is_child = isinstance(compiled_parent.nodelist[0], ExtendsNode) 
    100         parent_blocks = dict([(n.name, n) for n in compiled_parent.nodelist.get_nodes_by_type(BlockNode)]) 
    101         for block_node in self.nodelist.get_nodes_by_type(BlockNode): 
    102             # Check for a BlockNode with this node's name, and replace it if found. 
    103             try: 
    104                 parent_block = parent_blocks[block_node.name] 
    105             except KeyError: 
    106                 # This BlockNode wasn't found in the parent template, but the 
    107                 # parent block might be defined in the parent's *parent*, so we 
    108                 # add this BlockNode to the parent's ExtendsNode nodelist, so 
    109                 # it'll be checked when the parent node's render() is called. 
    110                 if parent_is_child: 
    111                     compiled_parent.nodelist[0].nodelist.append(block_node) 
    112             else: 
    113                 # Keep any existing parents and add a new one. Used by BlockNode. 
    114                 parent_block.parent = block_node.parent 
    115                 parent_block.add_parent(parent_block.nodelist) 
    116                 parent_block.nodelist = block_node.nodelist 
    117         return compiled_parent.render(context) 
    118  
    119 def do_block(parser, token): 
    120     """ 
    121     Define a block that can be overridden by child templates. 
    122     """ 
    123     bits = token.contents.split() 
    124     if len(bits) != 2: 
    125         raise template.TemplateSyntaxError, "'%s' tag takes only one argument" % bits[0] 
    126     block_name = bits[1] 
    127     # Keep track of the names of BlockNodes found in this template, so we can 
    128     # check for duplication. 
    129     try: 
    130         if block_name in parser.__loaded_blocks: 
    131             raise template.TemplateSyntaxError, "'%s' tag with name '%s' appears more than once" % (bits[0], block_name) 
    132         parser.__loaded_blocks.append(block_name) 
    133     except AttributeError: # parser._loaded_blocks isn't a list yet 
    134         parser.__loaded_blocks = [block_name] 
    135     nodelist = parser.parse(('endblock',)) 
    136     parser.delete_first_token() 
    137     return BlockNode(block_name, nodelist) 
    138  
    139 def do_extends(parser, token): 
    140     """ 
    141     Signal that this template extends a parent template. 
    142  
    143     This tag may be used in two ways: ``{% extends "base" %}`` (with quotes) 
    144     uses the literal value "base" as the name of the parent template to extend, 
    145     or ``{% entends variable %}`` uses the value of ``variable`` as the name 
    146     of the parent template to extend. 
    147     """ 
    148     bits = token.contents.split() 
    149     if len(bits) != 2: 
    150         raise template.TemplateSyntaxError, "'%s' takes one argument" % bits[0] 
    151     parent_name, parent_name_var = None, None 
    152     if (bits[1].startswith('"') and bits[1].endswith('"')) or (bits[1].startswith("'") and bits[1].endswith("'")): 
    153         parent_name = bits[1][1:-1] 
    154     else: 
    155         parent_name_var = bits[1] 
    156     nodelist = parser.parse() 
    157     if nodelist.get_nodes_by_type(ExtendsNode): 
    158         raise template.TemplateSyntaxError, "'%s' cannot appear more than once in the same template" % bits[0] 
    159     return ExtendsNode(nodelist, parent_name, parent_name_var) 
    160  
    161 template.register_tag('block', do_block) 
    162 template.register_tag('extends', do_extends) 
     7from django.core.template.loader import * 

  • django/trunk/django/core/template/loaders/filesystem.py

    r721 r867  
    1 # Wrapper for loading templates from files 
     1# Wrapper for loading templates from the filesystem. 
    22 
    33from django.conf.settings import TEMPLATE_DIRS, TEMPLATE_FILE_EXTENSION 

  • django/trunk/django/middleware/admin.py

    r669 r867  
    11from django.utils import httpwrappers 
    2 from django.core import template_loader 
    3 from django.core.extensions import DjangoContext as Context 
     2from django.core.extensions import DjangoContext 
     3from django.core.extensions import render_to_response 
    44from django.models.auth import users 
    55from django.views.registration import passwords 
    …… 
    9797        else: 
    9898            post_data = encode_post_data({}) 
    99         t = template_loader.get_template(self.get_login_template_name()) 
    100         c = Context(request, { 
     99        return render_to_response(self.get_login_template_name(), { 
    101100            'title': 'Log in', 
    102101            'app_path': request.path, 
    103102            'post_data': post_data, 
    104103            'error_message': error_message 
    105         }) 
    106         return httpwrappers.HttpResponse(t.render(c)) 
     104        }, context_instance=DjangoContext(request)) 
    107105 
    108106    def authenticate_user(self, user, password): 

  • django/trunk/django/views/admin/doc.py

    r665 r867  
    55from django.core.extensions import DjangoContext, render_to_response 
    66from django.core.exceptions import Http404, ViewDoesNotExist 
    7 from django.core import template, template_loader, defaulttags, defaultfilters, urlresolvers 
     7from django.core import template, template_loader, urlresolvers 
     8from django.core.template import defaulttags, defaultfilters 
    89try: 
    910    from django.parts.admin import doc 

  • django/trunk/django/views/admin/template.py

    r675 r867  
    1 from django.core import formfields, template_loader, validators 
     1from django.core import formfields, validators 
    22from django.core import template 
     3from django.core.template import loader 
    34from django.core.extensions import DjangoContext, render_to_response 
    45from django.models.core import sites 
    …… 
    5051        # for "extends" that uses the site's TEMPLATE_DIR instead 
    5152        def new_do_extends(parser, token): 
    52             node = template_loader.do_extends(parser, token) 
     53            node = loader.do_extends(parser, token) 
    5354            node.template_dirs = settings_module.TEMPLATE_DIRS 
    5455            return node 
    …… 
    5960        error = None 
    6061        try: 
    61             tmpl = template_loader.get_template_from_string(field_data) 
     62            tmpl = loader.get_template_from_string(field_data) 
    6263            tmpl.render(template.Context({})) 
    6364        except template.TemplateSyntaxError, e: 
    6465            error = e 
    65         template.register_tag('extends', template_loader.do_extends) 
     66        template.register_tag('extends', loader.do_extends) 
    6667        if error: 
    6768            raise validators.ValidationError, e.args 

  • django/trunk/django/views/auth/login.py