From 91ff82666d936433802979e3051a363ae131ce13 Mon Sep 17 00:00:00 2001 From: Stephen Burrows Date: Wed, 23 Feb 2011 10:48:27 -0500 Subject: [PATCH] Genericized nodelist_crawl to just pass each node to a callback function. Overloaded the Template.containers callback to create a blockcontext for handling containers in overridden blocks as per issue 90 and to handle contentreference/contentlet generation in a single sweep. --- models/pages.py | 63 +++++++++++++++++++++++++++++++++++++++---------- utils.py | 46 +++++++++++++++++++----------------- 2 files changed, 76 insertions(+), 33 deletions(-) diff --git a/models/pages.py b/models/pages.py index ef68b5f..1600768 100644 --- a/models/pages.py +++ b/models/pages.py @@ -5,7 +5,8 @@ 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 @@ -29,19 +30,57 @@ 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): + 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(DjangoTemplate(self.code).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') diff --git a/utils.py b/utils.py index deb009c..a968ac8 100644 --- a/utils.py +++ b/utils.py @@ -124,27 +124,31 @@ setattr(ExtendsNode, LOADED_TEMPLATE_ATTR, property(get_extended)) setattr(ConstantIncludeNode, LOADED_TEMPLATE_ATTR, property(get_included)) -def nodelist_crawl(nodelist, callback): - """This function crawls through a template's nodelist and the nodelists of any included or extended - templates, as determined by the presence and value of on a node. Each node - will also be passed to a callback function for additional processing.""" - results = [] +def default_callback(node, result_list): + result_list.append(node) + + if hasattr(node, 'child_nodelists'): + for nodelist_name in node.child_nodelists: + if hasattr(node, nodelist_name): + nodelist_crawl(getattr(node, nodelist_name), default_callback) + + # 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, default_callback) + + +def nodelist_crawl(nodelist, callback=default_callback, *args, **kwargs): + """This function crawls through a template's nodelist and the + nodelists of any included or extended templates, as determined by + the presence and value of on a node. Each + node will also be passed to a callback function for additional + processing, along with any additional args and kwargs.""" for node in nodelist: try: - if hasattr(node, 'child_nodelists'): - for nodelist_name in node.child_nodelists: - if hasattr(node, nodelist_name): - results.extend(nodelist_crawl(getattr(node, nodelist_name), callback)) - - # 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: - results.extend(nodelist_crawl(loaded_template.nodelist, callback)) - - callback(node, results) + callback(node, *args, **kwargs) except: - raise # fail for this node - return results \ No newline at end of file + raise # fail for this node \ No newline at end of file -- 2.20.1