Added STATIC_URL to context for icons.

[philo.git] / models / pages.py

diff --git a/models/pages.py b/models/pages.py
index fddb0ae..86db88f 100644 (file)
--- a/models/pages.py
+++ b/models/pages.py
@@ -5,30 +5,76 @@ from django.contrib.contenttypes import generic
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.http import HttpResponse
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.http import HttpResponse

-from django.template import TemplateDoesNotExist, Context, RequestContext, Template as DjangoTemplate, add_to_builtins as register_templatetags
+from django.template import TemplateDoesNotExist, Context, RequestContext, Template as DjangoTemplate, add_to_builtins as register_templatetags, TextNode, VariableNode
+from django.template.loader_tags import BlockNode, ExtendsNode, BlockContext
+from django.utils.datastructures import SortedDict

 from philo.models.base import TreeModel, register_value_model
 from philo.models.fields import TemplateField
 from philo.models.nodes import View
 from philo.templatetags.containers import ContainerNode
 from philo.models.base import TreeModel, register_value_model
 from philo.models.fields import TemplateField
 from philo.models.nodes import View
 from philo.templatetags.containers import ContainerNode

-from philo.utils import fattr, nodelist_crawl
+from philo.utils import fattr

 from philo.validators import LOADED_TEMPLATE_ATTR
 from philo.signals import page_about_to_render_to_string, page_finished_rendering_to_string
 
 
 from philo.validators import LOADED_TEMPLATE_ATTR
 from philo.signals import page_about_to_render_to_string, page_finished_rendering_to_string
 
 

+class LazyContainerFinder(object):
+       def __init__(self, nodes, extends=False):
+               self.nodes = nodes
+               self.initialized = False
+               self.contentlet_specs = set()
+               self.contentreference_specs = SortedDict()
+               self.blocks = {}
+               self.block_super = False
+               self.extends = extends
+       
+       def process(self, nodelist):
+               for node in nodelist:
+                       if self.extends:
+                               if isinstance(node, BlockNode):
+                                       self.blocks[node.name] = block = LazyContainerFinder(node.nodelist)
+                                       block.initialize()
+                                       self.blocks.update(block.blocks)
+                               continue
+                       
+                       if isinstance(node, ContainerNode):
+                               if not node.references:
+                                       self.contentlet_specs.add(node.name)
+                               else:
+                                       if node.name not in self.contentreference_specs.keys():
+                                               self.contentreference_specs[node.name] = node.references
+                               continue
+                       
+                       if isinstance(node, VariableNode):
+                               if node.filter_expression.var.lookups == (u'block', u'super'):
+                                       self.block_super = True
+                       
+                       if hasattr(node, 'child_nodelists'):
+                               for nodelist_name in node.child_nodelists:
+                                       if hasattr(node, nodelist_name):
+                                               nodelist = getattr(node, nodelist_name)
+                                               self.process(nodelist)
+                       
+                       # LOADED_TEMPLATE_ATTR contains the name of an attribute philo uses to declare a
+                       # node as rendering an additional template. Philo monkeypatches the attribute onto
+                       # the relevant default nodes and declares it on any native nodes.
+                       if hasattr(node, LOADED_TEMPLATE_ATTR):
+                               loaded_template = getattr(node, LOADED_TEMPLATE_ATTR)
+                               if loaded_template:
+                                       nodelist = loaded_template.nodelist
+                                       self.process(nodelist)
+       
+       def initialize(self):
+               if not self.initialized:
+                       self.process(self.nodes)
+                       self.initialized = True
+
+

 class Template(TreeModel):
        name = models.CharField(max_length=255)
        documentation = models.TextField(null=True, blank=True)
        mimetype = models.CharField(max_length=255, default=getattr(settings, 'DEFAULT_CONTENT_TYPE', 'text/html'))
        code = TemplateField(secure=False, verbose_name='django template code')
        
 class Template(TreeModel):
        name = models.CharField(max_length=255)
        documentation = models.TextField(null=True, blank=True)
        mimetype = models.CharField(max_length=255, default=getattr(settings, 'DEFAULT_CONTENT_TYPE', 'text/html'))
        code = TemplateField(secure=False, verbose_name='django template code')
        

-       @property
-       def origin(self):
-               return 'philo.models.Template: ' + self.path
-       
-       @property
-       def django_template(self):
-               return DjangoTemplate(self.code)
-       

        @property
        def containers(self):
                """
        @property
        def containers(self):
                """


@@ -37,31 +83,54 @@ class Template(TreeModel):
                This will break if there is a recursive extends or includes in the template code.
                Due to the use of an empty Context, any extends or include tags with dynamic arguments probably won't work.
                """
                This will break if there is a recursive extends or includes in the template code.
                Due to the use of an empty Context, any extends or include tags with dynamic arguments probably won't work.
                """

-               def process_node(node, nodes):
-                       if isinstance(node, ContainerNode):
-                               nodes.append(node)
+               template = DjangoTemplate(self.code)
+               
+               def build_extension_tree(nodelist):
+                       nodelists = []
+                       extends = None
+                       for node in nodelist:
+                               if not isinstance(node, TextNode):
+                                       if isinstance(node, ExtendsNode):
+                                               extends = node
+                                       break
+                       
+                       if extends:
+                               if extends.nodelist:
+                                       nodelists.append(LazyContainerFinder(extends.nodelist, extends=True))
+                               loaded_template = getattr(extends, LOADED_TEMPLATE_ATTR)
+                               nodelists.extend(build_extension_tree(loaded_template.nodelist))
+                       else:
+                               # Base case: root.
+                               nodelists.append(LazyContainerFinder(nodelist))
+                       return nodelists

                
                

-               all_nodes = nodelist_crawl(self.django_template.nodelist, process_node)
-               contentlet_node_names = set([node.name for node in all_nodes if not node.references])
-               contentreference_node_names = []
-               contentreference_node_specs = []
-               for node in all_nodes:
-                       if node.references and node.name not in contentreference_node_names:
-                               contentreference_node_specs.append((node.name, node.references))
-                               contentreference_node_names.append(node.name)
-               return contentlet_node_names, contentreference_node_specs
+               # Build a tree of the templates we're using, placing the root template first.
+               levels = build_extension_tree(template.nodelist)[::-1]
+               
+               contentlet_specs = set()
+               contentreference_specs = SortedDict()
+               blocks = {}
+               
+               for level in levels:
+                       level.initialize()
+                       contentlet_specs |= level.contentlet_specs
+                       contentreference_specs.update(level.contentreference_specs)
+                       for name, block in level.blocks.items():
+                               if block.block_super:
+                                       blocks.setdefault(name, []).append(block)
+                               else:
+                                       blocks[name] = [block]
+               
+               for block_list in blocks.values():
+                       for block in block_list:
+                               block.initialize()
+                               contentlet_specs |= block.contentlet_specs
+                               contentreference_specs.update(block.contentreference_specs)
+               
+               return contentlet_specs, contentreference_specs

        
        def __unicode__(self):
        
        def __unicode__(self):

-               return self.get_path(pathsep=u' › ', field='name')
-       
-       @staticmethod
-       @fattr(is_usable=True)
-       def loader(template_name, template_dirs=None): # load_template_source
-               try:
-                       template = Template.objects.get_with_path(template_name)
-               except Template.DoesNotExist:
-                       raise TemplateDoesNotExist(template_name)
-               return (template.code, template.origin)
+               return self.name

        
        class Meta:
                app_label = 'philo'
        
        class Meta:
                app_label = 'philo'


@@ -84,13 +153,14 @@ class Page(View):
                context = {}
                context.update(extra_context or {})
                context.update({'page': self, 'attributes': self.attributes})
                context = {}
                context.update(extra_context or {})
                context.update({'page': self, 'attributes': self.attributes})

+               template = DjangoTemplate(self.template.code)

                if request:
                        context.update({'node': request.node, 'attributes': self.attributes_with_node(request.node)})
                        page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)
                if request:
                        context.update({'node': request.node, 'attributes': self.attributes_with_node(request.node)})
                        page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)

-                       string = self.template.django_template.render(RequestContext(request, context))
+                       string = template.render(RequestContext(request, context))

                else:
                        page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)
                else:
                        page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)

-                       string = self.template.django_template.render(Context(context))
+                       string = template.render(Context(context))

                page_finished_rendering_to_string.send(sender=self, string=string)
                return string
        
                page_finished_rendering_to_string.send(sender=self, string=string)
                return string
        


@@ -124,7 +194,7 @@ class Page(View):
 
 class Contentlet(models.Model):
        page = models.ForeignKey(Page, related_name='contentlets')
 
 class Contentlet(models.Model):
        page = models.ForeignKey(Page, related_name='contentlets')

-       name = models.CharField(max_length=255)
+       name = models.CharField(max_length=255, db_index=True)

        content = TemplateField()
        
        def __unicode__(self):
        content = TemplateField()
        
        def __unicode__(self):


@@ -136,7 +206,7 @@ class Contentlet(models.Model):
 
 class ContentReference(models.Model):
        page = models.ForeignKey(Page, related_name='contentreferences')
 
 class ContentReference(models.Model):
        page = models.ForeignKey(Page, related_name='contentreferences')

-       name = models.CharField(max_length=255)
+       name = models.CharField(max_length=255, db_index=True)

        content_type = models.ForeignKey(ContentType, verbose_name='Content type')
        content_id = models.PositiveIntegerField(verbose_name='Content ID', blank=True, null=True)
        content = generic.GenericForeignKey('content_type', 'content_id')
        content_type = models.ForeignKey(ContentType, verbose_name='Content type')
        content_id = models.PositiveIntegerField(verbose_name='Content ID', blank=True, null=True)
        content = generic.GenericForeignKey('content_type', 'content_id')