Commits

Anonymous committed 7ece063

new-admin: Negligible syntax changes in django.core.template in preparation for merge to trunk

Comments (0)

Files changed (5)

django/core/template/__init__.py

 
 ALLOWED_VARIABLE_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.'
 
-#What to report as the origin of templates that come from non loader sources (ie strings)
+# what to report as the origin for templates that come from non-loader sources
+# (e.g. strings)
 UNKNOWN_SOURCE="<unknown source>"
 
 # match a variable or block tag and capture the entire tag, including start/end delimiters
 class Origin(object):
     def __init__(self, name):
         self.name = name
-        
+
     def reload(self):
         raise NotImplementedException
 
     def __init__(self, source):
         super(StringOrigin, self).__init__(UNKNOWN_SOURCE)
         self.source = source
-    
+
     def reload(self):
         return self.source
 
         "Compilation stage"
         if TEMPLATE_DEBUG and origin == None:
             origin = StringOrigin(template_string)
-            #Could do some crazy stack frame stuff to record where this string came from...
+            # Could do some crazy stack-frame stuff to record where this string
+            # came from...
         self.nodelist = compile_string(template_string, origin)
-       
+
     def __iter__(self):
         for node in self.nodelist:
             for subnode in node:
         return self.nodelist.render(context)
 
 def compile_string(template_string, origin):
-    "Compiles template_string into NodeList ready for rendering"     
+    "Compiles template_string into NodeList ready for rendering"
     lexer = lexer_factory(template_string, origin)
     parser = parser_factory(lexer.tokenize())
     return parser.parse()
             if dict.has_key(key):
                 return True
         return False
-    
+
     def get(self, key, otherwise):
         for dict in self.dicts:
             if dict.has_key(key):
 
     def __str__(self):
         return '<%s token: "%s...">' % (
-            {TOKEN_TEXT:'Text', TOKEN_VAR:'Var', TOKEN_BLOCK:'Block'}[self.token_type],
+            {TOKEN_TEXT: 'Text', TOKEN_VAR: 'Var', TOKEN_BLOCK: 'Block'}[self.token_type],
             self.contents[:20].replace('\n', '')
             )
-            
+
     def __repr__(self):
         return '<%s token: "%s">' % (
-            {TOKEN_TEXT:'Text', TOKEN_VAR:'Var', TOKEN_BLOCK:'Block'}[self.token_type],
+            {TOKEN_TEXT: 'Text', TOKEN_VAR: 'Var', TOKEN_BLOCK: 'Block'}[self.token_type],
             self.contents[:].replace('\n', '')
             )
 
     def __init__(self, template_string, origin):
         self.template_string = template_string
         self.origin = origin
-    
+
     def tokenize(self):
         "Return a list of tokens from a given template_string"
         # remove all empty strings, because the regex has a tendency to add them
         bits = filter(None, tag_re.split(self.template_string))
         return map(self.create_token, bits)
-        
+
     def create_token(self,token_string):
         "Convert the given token string into a new Token object and return it"
         if token_string.startswith(VARIABLE_TAG_START):
             token = Token(TOKEN_BLOCK, token_string[len(BLOCK_TAG_START):-len(BLOCK_TAG_END)].strip())
         else:
             token = Token(TOKEN_TEXT, token_string)
-        return token 
+        return token
 
 class DebugLexer(Lexer):
     def __init__(self, template_string, origin):
-        super(DebugLexer,self).__init__(template_string, origin)
+        super(DebugLexer, self).__init__(template_string, origin)
 
     def tokenize(self):
         "Return a list of tokens from a given template_string"
         token_tups, upto = [], 0
         for match in tag_re.finditer(self.template_string):
             start, end = match.span()
-            if start > upto:       
-                token_tups.append( (self.template_string[upto:start], (upto, start) ) )
+            if start > upto:
+                token_tups.append( (self.template_string[upto:start], (upto, start)) )
                 upto = start
-            token_tups.append( (self.template_string[start:end], (start,end) ) )
+            token_tups.append( (self.template_string[start:end], (start,end)) )
             upto = end
         last_bit = self.template_string[upto:]
         if last_bit:
-           token_tups.append( (last_bit, (upto, upto + len(last_bit) ) ) )
-        return [ self.create_token(tok, (self.origin, loc)) for tok, loc in token_tups]
+           token_tups.append( (last_bit, (upto, upto + len(last_bit))) )
+        return [self.create_token(tok, (self.origin, loc)) for tok, loc in token_tups]
 
     def create_token(self, token_string, source):
         token = super(DebugLexer, self).create_token(token_string)
                 try:
                     compile_func = registered_tags[command]
                 except KeyError:
-                    self.invalid_block_tag(token, command) 
+                    self.invalid_block_tag(token, command)
                 try:
                     compiled_result = compile_func(self, token)
                 except TemplateSyntaxError, e:
 
     def create_nodelist(self):
         return NodeList()
-    
+
     def extend_nodelist(self, nodelist, node, token):
         nodelist.append(node)
 
     def enter_command(self, command, token):
         pass
-        
+
     def exit_command(self):
         pass
 
 
     def empty_variable(self, token):
         raise self.error( token, "Empty variable tag")
-    
+
     def empty_block_tag(self, token):
         raise self.error( token, "Empty block tag")
-    
+
     def invalid_block_tag(self, token, command):
         raise self.error( token, "Invalid block tag: '%s'" % command)
-    
+
     def unclosed_block_tag(self, parse_until):
         raise self.error(None, "Unclosed tags: %s " %  ', '.join(parse_until))
 
     def compile_function_error(self, token, e):
         pass
-        
+
     def next_token(self):
         return self.tokens.pop(0)
 
 
     def delete_first_token(self):
         del self.tokens[0]
-    
+
 class DebugParser(Parser):
     def __init__(self, lexer):
         super(DebugParser, self).__init__(lexer)
 
     def enter_command(self, command, token):
         self.command_stack.append( (command, token.source) )
-        
+
     def exit_command(self):
         self.command_stack.pop()
 
     def extend_nodelist(self, nodelist, node, token):
         node.source = token.source
         super(DebugParser, self).extend_nodelist(nodelist, node, token)
-    
+
     def unclosed_block_tag(self, parse_until):
         (command, source) = self.command_stack.pop()
-        msg = "Unclosed tag '%s'. Looking for one of: %s " % \
-              (command, ', '.join(parse_until) ) 
+        msg = "Unclosed tag '%s'. Looking for one of: %s " % (command, ', '.join(parse_until))
         raise self.source_error( source, msg)
 
     def compile_function_error(self, token, e):
     'filter_sep': re.escape(FILTER_SEPARATOR),
     'arg_sep': re.escape(FILTER_ARGUMENT_SEPARATOR),
     'i18n_open' : re.escape("_("),
-    'i18n_close' : re.escape(")"),                         
+    'i18n_close' : re.escape(")"),
   }
-  
+
 filter_raw_string = filter_raw_string.replace("\n", "").replace(" ", "")
 filter_re = re.compile(filter_raw_string)
 
 class RegexFilterParser(object):
-    """ Not used yet because of i18n"""
-    
+    "Not used yet because of i18n"
     def __init__(self, token):
         matches = filter_re.finditer(token)
         var = None
             raise
         except Exception:
             from sys import exc_info
-            wrapped = TemplateSyntaxError( 'Caught exception whilst rendering' )
+            wrapped = TemplateSyntaxError('Caught an exception while rendering.')
             wrapped.source = node.source
             wrapped.exc_info = exc_info()
             raise wrapped
             return output.encode(DEFAULT_CHARSET)
         else:
             return output
-        
+
     def render(self, context):
         output = resolve_variable_with_filters(self.var_string, context)
         return self.encode_output(output)

django/core/template/defaulttags.py

         for obj in obj_list:
             grouper = resolve_variable_with_filters('var.%s' % self.expression, \
                 Context({'var': obj}))
-            #TODO: Is this a sensible way to determine equality? 
+            # TODO: Is this a sensible way to determine equality?
             if output and repr(output[-1]['grouper']) == repr(grouper):
                 output[-1]['list'].append(obj)
             else:

django/core/template/loader.py

 #
 # name is the template name.
 # dirs is an optional list of directories to search instead of TEMPLATE_DIRS.
+#
 # The loader should return a tuple of (template_source, path). The path returned
-# will be shown to the user for debugging purposes, so it should identify where the template 
-# was loaded from.  
+# might be shown to the user for debugging purposes, so it should identify where
+# the template was loaded from.
 #
 # Each loader should have an "is_usable" attribute set. This is a boolean that
 # specifies whether the loader can be used in this Python installation. Each
     def __init__(self, display_name, loader, name, dirs):
         super(LoaderOrigin, self).__init__(display_name)
         self.loader, self.loadname, self.dirs = loader, name, dirs
-    
+
     def reload(self):
         return self.loader(self.loadname, self.dirs)[0]
 
     Loads the given template_name and renders it with the given dictionary as
     context. The template_name may be a string to load a single template using
     get_template, or it may be a tuple to use select_template to find one of
-    the templates in the list.  Returns a string. 
+    the templates in the list. Returns a string.
     """
     dictionary = dictionary or {}
     if isinstance(template_name, (list, tuple)):
     if context_instance:
         context_instance.update(dictionary)
     else:
-        context_instance = Context(dictionary) 
+        context_instance = Context(dictionary)
     return t.render(context_instance)
 
 def select_template(template_name_list):
     def __init__(self, template_path):
         try:
             t = get_template(template_path)
-            self.nodelist = t.nodelist
+            self.template = t
         except Exception, e:
             if TEMPLATE_DEBUG:
                 raise
-            self.nodelist = None
+            self.template = None
 
     def render(self, context):
-        if self.nodelist:
-            return self.nodelist.render(context)
+        if self.template:
+            return self.template.render(context)
         else:
             return ''
 
 class IncludeNode(Node):
-    def __init__(self, template_path_var):
-        self.template_path_var = template_path_var
+    def __init__(self, template_name):
+        self.template_name = template_name
 
     def render(self, context):
          try:
-             template_path = resolve_variable(self.template_path_var, context)
-             t = get_template(template_path)
+             template_name = resolve_variable(self.template_name, context)
+             t = get_template(template_name)
              return t.render(context)
          except Exception, e:
              if TEMPLATE_DEBUG:

django/core/template/loaders/app_directories.py

     template_dir = os.path.join(os.path.dirname(mod.__file__), 'templates')
     if os.path.isdir(template_dir):
         app_template_dirs.append(template_dir)
-        
+
 # It won't change, so convert it to a tuple to save memory.
 app_template_dirs = tuple(app_template_dirs)
 

django/core/template/loaders/eggs.py

         pkg_name = 'templates/' + template_name + TEMPLATE_FILE_EXTENSION
         for app in INSTALLED_APPS:
             try:
-                return (resource_string(app, pkg_name), 'egg:%s:%s ' % (app, pkg_name)) 
+                return (resource_string(app, pkg_name), 'egg:%s:%s ' % (app, pkg_name))
             except:
                 pass
     raise TemplateDoesNotExist, template_name