Add render_block function (#60)

Add a render_block function, which returns a HttpResponse object
with the content set to the results of calling render_block_to_string.

Author: gogognome

CHANGELOG.rst

@@ -6,6 +6,13 @@ Changelog
 next
 ====
 
+Improvements
+------------
+
+* Add a new ``render_block`` function which returns a `HttpResponse` with the content
+  set to the result of calling ``render_block_to_string()``. Contributed by
+  `@gogognome <https://github.com/gogognome>`_. (`#60 <https://github.com/clokep/django-render-block/pull/60>`_)
+
 Maintenance
 -----------
 

README.rst

@@ -71,7 +71,7 @@ And from Python:
 API Reference
 =============
 
-The API is simple and attempts to mirror the built-in ``render_to_string`` API.
+The API is simple and attempts to mirror the built-in ``render_to_string`` and ``render`` API.
 
 ``render_block_to_string(template_name, block_name, context=None, request=None)``
 
@@ -95,6 +95,34 @@ The API is simple and attempts to mirror the built-in ``render_to_string`` API.
         ``request`` is optional and works only for Django templates. If both context and request
         are provided, a ``RequestContext`` will be used instead of a ``Context``.
 
+Similarly there is a ``render_block`` function which returns an `HttpResponse` with
+the content sent to the result of ``render_block_to_string`` with the same parameters.
+
+``render_block(request, template_name, block_name, context=None, content_type="text/html", status=200)``
+
+    ``request``
+        The request object used to render the template.
+
+    ``template_name``
+        The name of the template to load and render. If it’s a list of template
+        names, Django uses ``select_template()`` instead of ``get_template()``
+        to find the template.
+
+    ``block_name``
+        The name of the block to render from the above template.
+
+    ``context``
+        A ``dict`` to be used as the template’s context for rendering. A ``Context``
+        object can be provided for Django templates.
+
+        ``context`` is optional. If not provided, an empty context will be used.
+
+    ``content_type``
+        A ``str`` content type for the HTTP response.
+
+    ``status``
+        An ``int`` HTTP status code for the HTTP response.
+
 Exceptions
 ----------
 

render_block/__init__.py

@@ -1,4 +1,9 @@
-from render_block.base import render_block_to_string
+from render_block.base import render_block, render_block_to_string
 from render_block.exceptions import BlockNotFound, UnsupportedEngine
 
-__all__ = ["BlockNotFound", "UnsupportedEngine", "render_block_to_string"]
+__all__ = [
+    "BlockNotFound",
+    "UnsupportedEngine",
+    "render_block",
+    "render_block_to_string",
+]

render_block/base.py

@@ -1,6 +1,6 @@
 from typing import List, Optional, Tuple, Union
 
-from django.http import HttpRequest
+from django.http import HttpRequest, HttpResponse
 from django.template import Context, loader
 from django.template.backends.django import Template as DjangoTemplate
 
@@ -27,10 +27,13 @@ def render_block_to_string(
     Loads the given template_name and renders the given block with the given
     dictionary as context. Returns a string.
 
-        template_name
+    :param template_name:
             The name of the template to load and render. If it's a list of
             template names, Django uses select_template() instead of
             get_template() to find the template.
+    :param block_name: The name of the block to load.
+    :param context: The context dictionary used while rendering the template.
+    :param request: The request that triggers the rendering of the block.
     """
 
     # Like render_to_string, template_name can be a string or a list/tuple.
@@ -55,3 +58,19 @@ def render_block_to_string(
         raise UnsupportedEngine(
             "Can only render blocks from the Django template backend."
         )
+
+
+def render_block(
+    request: HttpRequest,
+    template_name: str,
+    block_name: str,
+    context: Optional[Context] = None,
+    content_type: Optional[str] = None,
+    status: Optional[int] = None,
+) -> HttpResponse:
+    """
+    Return an HttpResponse whose content is filled with the result of calling
+    render_block.render_block_to_string() with the passed arguments.
+    """
+    content = render_block_to_string(template_name, block_name, context, request)
+    return HttpResponse(content, content_type, status)

tests/tests.py

@@ -3,7 +3,12 @@
 from django.template import Context
 from django.test import RequestFactory, TestCase, modify_settings, override_settings
 
-from render_block import BlockNotFound, UnsupportedEngine, render_block_to_string
+from render_block import (
+    BlockNotFound,
+    UnsupportedEngine,
+    render_block,
+    render_block_to_string,
+)
 
 
 class TestDjango(TestCase):
@@ -174,6 +179,20 @@ def test_request_context(self) -> None:
 
         self.assertEqual(result, "/dummy-url")
 
+    @modify_settings(
+        INSTALLED_APPS={
+            "prepend": [
+                "django.contrib.auth",
+                "django.contrib.contenttypes",
+            ],
+        },
+    )
+    def test_render_block(self) -> None:
+        """Test rendering an individual block to a response."""
+        request = RequestFactory().get("dummy-url")
+        response = render_block(request, "test1.html", "block1")
+        self.assertEqual(response.content, b"block1 from test1")
+
 
 @override_settings(
     TEMPLATES=[
@@ -185,7 +204,7 @@ def test_request_context(self) -> None:
     ]
 )
 class TestJinja2(TestCase):
-    """Test the Django templating engine."""
+    """Test the Jinja2 templating engine."""
 
     def assertExceptionMessageEquals(self, exception: Exception, expected: str) -> None:
         self.assertEqual(expected, exception.args[0])
@@ -271,3 +290,17 @@ def test_context(self) -> None:
         data = "block2 from test5"
         result = render_block_to_string("test5.html", "block2", {"foo": data})
         self.assertEqual(result, data)
+
+    @modify_settings(
+        INSTALLED_APPS={
+            "prepend": [
+                "django.contrib.auth",
+                "django.contrib.contenttypes",
+            ],
+        },
+    )
+    def test_render_block(self) -> None:
+        """Test rendering an individual block to a response."""
+        request = RequestFactory().get("dummy-url")
+        response = render_block(request, "test1.html", "block1")
+        self.assertEqual(response.content, b"block1 from test1")