From: Harris Lapiroff <hlapirof@oberlin.edu>
Date: Wed, 2 Mar 2011 19:59:25 +0000 (-0500)
Subject: Merge remote branch 'melinath/master'
X-Git-Tag: philo-0.9~17^2~4^2
X-Git-Url: http://git.ithinksw.org/philo.git/commitdiff_plain/b8668727caf6da1e8425fd32334a4ec5919ce4a2?hp=77f783071cd3c6246a90dc6aa869b4efe7610379

Merge remote branch 'melinath/master'
---

diff --git a/admin/forms/containers.py b/admin/forms/containers.py
index 181a3e7..420ba17 100644
--- a/admin/forms/containers.py
+++ b/admin/forms/containers.py
@@ -169,19 +169,19 @@ class ContentletInlineFormSet(ContainerInlineFormSet):
 class ContentReferenceInlineFormSet(ContainerInlineFormSet):
 	def get_containers(self):
 		try:
-			containers = list(self.instance.containers[1])
+			containers = self.instance.containers[1]
 		except ObjectDoesNotExist:
-			containers = []
+			containers = {}
 		
 		filter = Q()
-		for name, ct in containers:
+		for name, ct in containers.items():
 			filter |= Q(name=name, content_type=ct)
 		qs = self.get_queryset().filter(filter)
 		
 		container_dict = SortedDict([(container.name, container) for container in qs])
 		
 		keyOrder = []
-		for name, ct in containers:
+		for name, ct in containers.items():
 			keyOrder.append(name)
 			if name not in container_dict:
 				container_dict[name] = self.model(name=name, content_type=ct)
diff --git a/contrib/penfield/admin.py b/contrib/penfield/admin.py
index 950539d..328394a 100644
--- a/contrib/penfield/admin.py
+++ b/contrib/penfield/admin.py
@@ -1,5 +1,7 @@
-from django.contrib import admin
 from django import forms
+from django.contrib import admin
+from django.core.urlresolvers import reverse
+from django.http import HttpResponseRedirect, QueryDict
 from philo.admin import EntityAdmin, AddTagAdmin, COLLAPSE_CLASSES
 from philo.contrib.penfield.models import BlogEntry, Blog, BlogView, Newsletter, NewsletterArticle, NewsletterIssue, NewsletterView
 
@@ -91,10 +93,18 @@ class NewsletterArticleAdmin(TitledAdmin, AddTagAdmin):
 			'classes': COLLAPSE_CLASSES
 		})
 	)
+	actions = ['make_issue']
 	
 	def author_names(self, obj):
 		return ', '.join([author.get_full_name() for author in obj.authors.all()])
 	author_names.short_description = "Authors"
+	
+	def make_issue(self, request, queryset):
+		opts = NewsletterIssue._meta
+		info = opts.app_label, opts.module_name
+		url = reverse("admin:%s_%s_add" % info)
+		return HttpResponseRedirect("%s?articles=%s" % (url, ",".join([str(a.pk) for a in queryset])))
+	make_issue.short_description = u"Create issue from selected %(verbose_name_plural)s"
 
 
 class NewsletterIssueAdmin(TitledAdmin):
diff --git a/contrib/shipherd/templatetags/shipherd.py b/contrib/shipherd/templatetags/shipherd.py
index 317fffb..83e98a2 100644
--- a/contrib/shipherd/templatetags/shipherd.py
+++ b/contrib/shipherd/templatetags/shipherd.py
@@ -82,14 +82,15 @@ def recursenavigation(parser, token):
 	{{ navloop.revcounter }}, {{ navloop.revcounter0 }}, {{ navloop.first }}, {{ navloop.last }},
 	and {{ navloop.parentloop }} in the context.
 	
-	Note that the tag takes one variable, which is a Node instance.
+	Note that the tag takes two variables: a Node instance and the key of the navigation to
+	be recursed.
 	
 	Usage:
 		<ul>
 			{% recursenavigation node main %}
 				<li{% if active %} class='active'{% endif %}>
-					{{ navigation.text }}
-					{% if navigation.get_children %}
+					{{ item.text }}
+					{% if children %}
 						<ul>
 							{{ children }}
 						</ul>
diff --git a/media/admin/js/TagCreation.js b/media/admin/js/TagCreation.js
index 31f2910..d08d41e 100644
--- a/media/admin/js/TagCreation.js
+++ b/media/admin/js/TagCreation.js
@@ -1,6 +1,29 @@
 var tagCreation = window.tagCreation;
 
 (function($) {
+	location_re = new RegExp("^https?:\/\/" + window.location.host + "/")
+	
+	$('html').ajaxSend(function(event, xhr, settings) {
+		function getCookie(name) {
+			var cookieValue = null;
+			if (document.cookie && document.cookie != '') {
+				var cookies = document.cookie.split(';');
+				for (var i = 0; i < cookies.length; i++) {
+					var cookie = $.trim(cookies[i]);
+					// Does this cookie string begin with the name we want?
+					if (cookie.substring(0, name.length + 1) == (name + '=')) {
+						cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+						break;
+					}
+				}
+			}
+			return cookieValue;
+		}
+		if (!(/^http:.*/.test(settings.url) || /^https:.*/.test(settings.url)) || location_re.test(settings.url)) {
+			// Only send the token to relative URLs i.e. locally.
+			xhr.setRequestHeader("X-CSRFToken", getCookie('csrftoken'));
+		}
+	});
 	tagCreation = {
 		'cache': {},
 		'addTagFromSlug': function(triggeringLink) {
diff --git a/models/pages.py b/models/pages.py
index ef68b5f..39125ef 100644
--- a/models/pages.py
+++ b/models/pages.py
@@ -5,16 +5,71 @@ 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
 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
 
 
+class LazyContainerFinder(object):
+	def __init__(self, nodes):
+		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):
+				self.blocks[node.name] = block = LazyContainerFinder(node.nodelist)
+				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
+
+
 class Template(TreeModel):
 	name = models.CharField(max_length=255)
 	documentation = models.TextField(null=True, blank=True)
@@ -29,19 +84,51 @@ 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]
+		
+		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)
 		
-		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
+		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..57f949e 100644
--- a/utils.py
+++ b/utils.py
@@ -121,30 +121,4 @@ def get_included(self):
 
 # We ignore the IncludeNode because it will never work in a blank context.
 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 <LOADED_TEMPLATE_ATTR> on a node. Each node
-	will also be passed to a callback function for additional processing."""
-	results = []
-	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)
-		except:
-			raise # fail for this node
-	return results
\ No newline at end of file
+setattr(ConstantIncludeNode, LOADED_TEMPLATE_ATTR, property(get_included))
\ No newline at end of file