X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/74ceac458ad030558f2e564ba34191115d0aadc5..9c0a07cbbdf9fdf91537e92527c1272acac15201:/models/pages.py?ds=sidebyside diff --git a/models/pages.py b/models/pages.py index 16098d1..4da5e99 100644 --- a/models/pages.py +++ b/models/pages.py @@ -2,9 +2,12 @@ from django.conf import settings from django.contrib.contenttypes.models import ContentType from django.contrib.contenttypes import generic +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 @@ -14,20 +17,72 @@ 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): + _created = 0 + _initialized = 0 + + def __init__(self, nodes): + self.__class__._created += 1 + self.nodes = nodes + self.initialized = False + self.contentlet_specs = set() + self.contentreference_specs = SortedDict() + self.blocks = {} + self.block_super = False + + def process(self, nodelist): + for node in nodelist: + 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, BlockNode): + #if nodelist == self.nodes: Necessary? + self.blocks[node.name] = block = LazyContainerFinder(node.nodelist) + if block.nodes.get_nodes_by_type(BlockNode): # Is this faster? + block.initialize() + self.blocks.update(block.blocks) + continue + + if isinstance(node, ExtendsNode): + 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 + self.__class__._initialized += 1 + + 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): """ @@ -36,32 +91,55 @@ 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. """ - 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)) + 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 + + # Build a tree of the templates we're using, placing the root template first. + levels = build_extension_tree(template.nodelist)[::-1] - 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 + 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): 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) - class Meta: app_label = 'philo' @@ -79,33 +157,52 @@ class Page(View): return self._containers containers = property(get_containers) - def render_to_string(self, node=None, request=None, path=None, subpath=None, extra_context=None): + def render_to_string(self, request=None, extra_context=None): context = {} context.update(extra_context or {}) context.update({'page': self, 'attributes': self.attributes}) - if node and request: - context.update({'node': node, 'attributes': self.attributes_with_node(node)}) - page_about_to_render_to_string.send(sender=self, node=node, request=request, extra_context=context) - string = self.template.django_template.render(RequestContext(request, context)) + 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) + string = template.render(RequestContext(request, context)) else: - page_about_to_render_to_string.send(sender=self, node=node, request=request, extra_context=context) - string = self.template.django_template.render(Context(context)) + page_about_to_render_to_string.send(sender=self, request=request, extra_context=context) + string = template.render(Context(context)) page_finished_rendering_to_string.send(sender=self, string=string) return string - def actually_render_to_response(self, node, request, path=None, subpath=None, extra_context=None): - return HttpResponse(self.render_to_string(node, request, path, subpath, extra_context), mimetype=self.template.mimetype) + def actually_render_to_response(self, request, extra_context=None): + return HttpResponse(self.render_to_string(request, extra_context), mimetype=self.template.mimetype) def __unicode__(self): return self.title + def clean_fields(self, exclude=None): + try: + super(Page, self).clean_fields(exclude) + except ValidationError, e: + errors = e.message_dict + else: + errors = {} + + if 'template' not in errors and 'template' not in exclude: + try: + self.template.clean_fields() + self.template.clean() + except ValidationError, e: + errors['template'] = e.messages + + if errors: + raise ValidationError(errors) + class Meta: app_label = 'philo' 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): @@ -117,7 +214,7 @@ class Contentlet(models.Model): 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')