Added a middleware to handle all the requests

Cleaned up some code

Author: brokenseal

partial_load/decorators.py

@@ -1,4 +1,4 @@
-from django.template.response import TemplateResponse, HttpResponse
+from django.template.response import HttpResponse, SimpleTemplateResponse
 from partial_load import loader
 from json import dumps
 
@@ -8,12 +8,14 @@ def _inner(request, *args, **kwargs):
         response = func(request, *args, **kwargs)
 
         if request.is_ajax() and request.META.has_key('HTTP_X_LOAD_BLOCKS'):
-            if not isinstance(response, TemplateResponse):
+            if not isinstance(response, SimpleTemplateResponse):
                 raise Exception("The response must be an instance of TemplateResponse.")
 
             block_list = request.META['HTTP_X_LOAD_BLOCKS'].split(',')
             result = loader.render_template_blocks(response.template, block_list, response.context)
 
             return HttpResponse(dumps(result), mimetype="application/json")
-            
+
+        return response
+    
     return _inner

partial_load/loader.py

@@ -1,83 +1,35 @@
 from django.template.loader_tags import BlockNode, ExtendsNode
-from django.template import loader, Context, RequestContext
-from django.http import HttpResponse
+from django.template import loader, Context
 
 
 
-class BlockNotFound(Exception):
-    pass
-
-
 def get_template(template):
     if isinstance(template, (tuple, list)):
         return loader.select_template(template)
     return loader.get_template(template)
 
 def render_template_blocks(template, block_list, context):
     """
-    Renders a single block from a template. This template should have previously been rendered.
+        Renders a list of blocks from a template.
+        Return a dictionary of rendered template blocks.
     """
-    return render_template_blocks_nodelist(template.nodelist, block_list, context)
+    return render_blocks(template.nodelist, block_list, context)
 
-def render_template_blocks_nodelist(nodelist, block_list, context):
+def render_blocks(nodelist, block_list, context):
     block_map = {}
-
+    
     for node in nodelist:
         if isinstance(node, BlockNode) and node.name in block_list:
             block_map.setdefault(node.name, node.render(Context(context)))
 
         for key in ('nodelist', 'nodelist_true', 'nodelist_false'):
             if hasattr(node, key):
-                try:
-                    inner_block_map = render_template_blocks_nodelist(getattr(node, key), block_list, context)
-                except:
-                    pass
-                else:
-                    block_map.update(inner_block_map)
-                    inner_block_map = {}
+                inner_block_map = render_blocks(getattr(node, key), block_list, context)
+                block_map.update(inner_block_map)
 
     for node in nodelist:
         if isinstance(node, ExtendsNode):
-            try:
-                inner_block_map = render_template_blocks(node.get_parent(context), block_list, context)
-            except BlockNotFound:
-                pass
-            else:
-                block_map.update(inner_block_map)
+            inner_block_map = render_template_blocks(node.get_parent(context), block_list, context)
+            block_map.update(inner_block_map)
 
-    return block_map
-
-def render_block_to_string(template_name, block_list, dictionary={}, context_instance=None):
-    """
-    Loads the given template_name and renders the given block with the given dictionary as
-    context. Returns a string.
-    """
-    template = get_template(template_name)
-    
-    if context_instance is not None:
-        context_instance.update(dictionary)
-    else:
-        context_instance = Context(dictionary)
-        
-    template.render(context_instance)
-    
-    return render_template_blocks(template, block_list, context_instance)
-
-def direct_block_to_template(request, template, block_list, extra_context=None, mimetype=None, **kwargs):
-    """
-    Render a given block in a given template with any extra URL parameters in the context as
-    ``{{ params }}``.
-    """
-    if extra_context is None:
-        extra_context = {}
-    dictionary = {'params': kwargs}
-    for key, value in extra_context.items():
-        if callable(value):
-            dictionary[key] = value()
-        else:
-            dictionary[key] = value
-    c = RequestContext(request, dictionary)
-    t = get_template(template)
-    t.render(c)
-    
-    return HttpResponse(render_template_blocks(t, block_list, c), mimetype=mimetype)
+    return block_map

partial_load/middleware.py

@@ -0,0 +1,19 @@
+from json import dumps
+
+from django.template.response import SimpleTemplateResponse
+from django.http import HttpResponse
+
+from partial_load import loader
+
+
+class PartialLoadMiddleware(object):
+    def process_response(self, request, response):
+        # since the middleware is a most generic way of handling with the request/response process, let's check
+        # if the response is a SimpleTemplateResponse instance first
+        if request.is_ajax() and isinstance(response, SimpleTemplateResponse)\
+                and request.META.has_key('HTTP_X_LOAD_BLOCKS'):
+            
+            block_list = request.META['HTTP_X_LOAD_BLOCKS'].split(',')
+            result = loader.render_template_blocks(response.template, block_list, response.context)
+
+            return HttpResponse(dumps(result), mimetype="application/json")