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 philo.models.base import TreeModel, register_value_model
from philo.models.fields import TemplateField
from philo.models.nodes import View
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):
"""
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):
+ def process_node(node, contentlet_specs, contentreference_specs, contentreference_names, block_context=None):
if isinstance(node, ContainerNode):
- nodes.append(node)
+ if not node.references:
+ if node.name not in contentlet_specs:
+ contentlet_specs.append(node.name)
+ else:
+ if node.name not in contentreference_names:
+ contentreference_specs.append((node.name, node.references))
+ contentreference_names.add(node.name)
+ if isinstance(node, ExtendsNode) and block_context is not None:
+ block_context.add_blocks(node.blocks)
+ parent = getattr(node, LOADED_TEMPLATE_ATTR)
+ for node in parent.nodelist:
+ if not isinstance(node, TextNode):
+ if not isinstance(node, ExtendsNode):
+ blocks = dict([(n.name, n) for n in parent.nodelist.get_nodes_by_type(BlockNode)])
+ block_context.add_blocks(blocks)
+ break
+
+ if hasattr(node, 'child_nodelists') and not isinstance(node, BlockNode):
+ for nodelist_name in node.child_nodelists:
+ if hasattr(node, nodelist_name):
+ nodelist_crawl(getattr(node, nodelist_name), process_node, contentlet_specs, contentreference_specs, contentreference_names, block_context)
+
+ # 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_crawl(loaded_template.nodelist, process_node, contentlet_specs, contentreference_specs, contentreference_names, block_context)
- 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
+ contentreference_names = set()
+ contentlet_specs = []
+ contentreference_specs = []
+ block_context = BlockContext()
+ nodelist_crawl(DjangoTemplate(self.code).nodelist, process_node, contentlet_specs, contentreference_specs, contentreference_names, block_context)
+
+ def process_block_node(node, contentlet_specs, contentreference_specs, contentreference_names, block_super):
+ if isinstance(node, VariableNode) and node.filter_expression.var.lookups == (u'block', u'super'):
+ block_super.append(node)
+ process_node(node, contentlet_specs, contentreference_specs, contentreference_names, block_context=None)
+
+ for block_list in block_context.blocks.values():
+ for block in block_list[::-1]:
+ block_super = []
+ nodelist_crawl(block.nodelist, process_block_node, contentlet_specs, contentreference_specs, contentreference_names, block_super)
+ if not block_super:
+ break
+
+ 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'
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, 'relationships': self.relationships})
- if node and request:
- context.update({'node': node, 'attributes': self.attributes_with_node(node), 'relationships': self.relationships_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))
+ 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)
+ 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):
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')
git.ithinksw.org / philo.git / blobdiff