Ticket #6237: t.w.template-adapter-support-6237.patch

twisted/web/_flatten.py

@@ -179 +179 @@
         yield root.addCallback(
             lambda result: (result, _flattenElement(request, result, slotData,
                                              renderFactory, inAttribute)))
-    elif IRenderable.providedBy(root):
-        result = root.render(request)
-        yield _flattenElement(request, result, slotData, root, inAttribute)
     else:
-        raise UnsupportedType(root)
+        try:
+            renderer = IRenderable(root)
+        except TypeError:
+            raise UnsupportedType(root)
+        result = renderer.render(request)
+        yield _flattenElement(request, result, slotData, renderer, inAttribute)
 
 
 def _flattenTree(request, root):

twisted/web/test/test_flatten.py

@@ -1 @@
-
 # Copyright (c) Twisted Matrix Laboratories.
 # See LICENSE for details.
 
@@ -9 +8 @@
 
 from twisted.trial.unittest import TestCase
 from twisted.internet.defer import succeed, gatherResults
+from twisted.python import components
+from twisted.python.test.test_components import RegistryUsingMixin
 from twisted.web._stan import Tag
 from twisted.web._flatten import flattenString
 from twisted.web.error import UnfilledSlot, UnsupportedType, FlattenerError
@@ -17 +18 @@
 from twisted.web.test._util import FlattenTestCase
 
 
+
+class FakeElement(object):
+    """
+    A fake L{IRenderable} that returns a document with a specified
+    hole, to test both parts of the L{IRenderable} interface.
+
+    @type testcase: L{TestCase}
+    @ivar testcase: the test case to which asserts should be directed
+    """
+
+    implements(IRenderable)
+
+    def __init__(self, testcase):
+        self.testcae = testcase
+
+
+    def render(self, req):
+        """
+        Returns a document with holes to be filled by
+        C{lookupRenderMethod}.
+
+        @param req: (ignored)
+
+        @return: a document
+        """
+        return tags.p(
+            'hello, ',
+            tags.transparent(render='test'), ' - ',
+            tags.transparent(render='test'))
+
+
+    def lookupRenderMethod(self, name):
+        """
+        Returns a method to handle the hole C{test}, and asserts that the hole
+        is in fact C{test}.
+
+        @param name: the string C{"test"}
+        @return: render method for C{test} hole
+        """
+        self.testcase.assertEqual(name, 'test')
+        return lambda ign, node: node('world')
+
+
+
 class TestSerialization(FlattenTestCase):
     """
     Tests for flattening various things.
@@ -163 +208 @@
         """
         Test that flattening respects all of the IRenderable interface.
         """
-        class FakeElement(object):
-            implements(IRenderable)
-            def render(ign,ored):
-                return tags.p(
-                    'hello, ',
-                    tags.transparent(render='test'), ' - ',
-                    tags.transparent(render='test'))
-            def lookupRenderMethod(ign, name):
-                self.assertEqual(name, 'test')
-                return lambda ign, node: node('world')
-
         return gatherResults([
-            self.assertFlattensTo(FakeElement(), '<p>hello, world - world</p>'),
+            self.assertFlattensTo(FakeElement(self), '<p>hello, world - world</p>'),
         ])
 
 
@@ -209 +243 @@
         return self.assertFlatteningRaises(None, UnsupportedType)
 
 
+
+class TestAdapterSerialization(RegistryUsingMixin, FlattenTestCase):
+    """
+    Tests for flattening various things that use the global adapter registry.
+    """
+
+    def test_serializeAdaptableRender(self):
+        """
+        Tests that flattening an object adaptable to an L{IRenderable} uses
+        the adapter.
+        """
+        class FakeAdaptee(object):
+            pass
+
+        components.registerAdapter(lambda _: FakeElement(self), FakeAdaptee, IRenderable)
+
+        return gatherResults([
+            self.assertFlattensTo(FakeAdaptee(), '<p>hello, world - world</p>'),
+        ])
+
+
+
+
 # Use the co_filename mechanism (instead of the __file__ mechanism) because
 # it is the mechanism traceback formatting uses.  The two do not necessarily
 # agree with each other.  This requires a code object compiled in this file.