plone.tiles 3.0.0__py3-none-any.whl

plone/tiles/meta.zcml

@@ -0,0 +1,16 @@
+<configure
+    xmlns="http://namespaces.zope.org/zope"
+    xmlns:meta="http://namespaces.zope.org/meta"
+    >
+
+  <meta:directives namespace="http://namespaces.plone.org/plone">
+
+    <meta:directive
+        name="tile"
+        handler=".meta.tile"
+        schema=".meta.ITileDirective"
+        />
+
+  </meta:directives>
+
+</configure>

plone/tiles/test.pt

@@ -0,0 +1 @@
+<b i18n:ignore="">test!</b>

plone/tiles/testing.py

@@ -0,0 +1,59 @@
+from plone.testing import Layer
+from plone.testing import z2
+from plone.testing import zca
+from plone.tiles import PersistentTile
+from plone.tiles import Tile
+from zope import schema
+from zope.configuration import xmlconfig
+from zope.interface import Interface
+
+
+# For directive tests
+
+
+class IDummySchema(Interface):
+    foo = schema.TextLine(title="Foo")
+
+
+class IDummyContext(Interface):
+    pass
+
+
+class IDummyLayer(Interface):
+    pass
+
+
+class DummyTile(Tile):
+
+    def __call__(self):
+        return "dummy"
+
+
+class DummyTileWithTemplate(PersistentTile):
+    pass
+
+
+class PloneTiles(Layer):
+    defaultBases = (z2.STARTUP,)
+
+    def setUp(self):
+        self["configurationContext"] = context = zca.stackConfigurationContext(
+            self.get("configurationContext")
+        )
+        import zope.annotation
+
+        xmlconfig.file("configure.zcml", zope.annotation, context=context)
+        import plone.tiles
+
+        xmlconfig.file("configure.zcml", plone.tiles, context=context)
+
+    def tearDown(self):
+        del self["configurationContext"]
+
+
+PLONE_TILES_FIXTURE = PloneTiles()
+
+
+PLONE_TILES_INTEGRATION_TESTING = z2.IntegrationTesting(
+    bases=(PLONE_TILES_FIXTURE,), name="PloneTiles:Functional"
+)

plone/tiles/tests/test_data.py

@@ -0,0 +1,83 @@
+from plone.rfc822.interfaces import IPrimaryField
+from plone.tiles.data import decode
+from plone.tiles.data import encode
+from plone.tiles.testing import PLONE_TILES_INTEGRATION_TESTING
+from zope import schema
+from zope.interface import alsoProvides
+from zope.interface import Interface
+
+import unittest
+
+
+class IQuerySchema(Interface):
+
+    query = schema.List(
+        title="Search terms",
+        value_type=schema.Dict(value_type=schema.Field(), key_type=schema.TextLine()),
+        required=False,
+    )
+
+    lines = schema.List(title="Strings", value_type=schema.TextLine(), required=False)
+
+    title = schema.TextLine(title="Title")
+
+
+class IWords(Interface):
+
+    words = schema.List(title="Words", value_type=schema.TextLine(), required=False)
+
+
+class IPrimary(Interface):
+
+    words = schema.List(title="Words", value_type=schema.TextLine(), required=False)
+
+
+alsoProvides(IPrimary["words"], IPrimaryField)
+
+
+class TestEncode(unittest.TestCase):
+
+    layer = PLONE_TILES_INTEGRATION_TESTING
+
+    def test_encode_querystring_special(self):
+        data = {
+            "query": [
+                {
+                    "i": "Subject",
+                    "o": "plone.app.querystring.operation.selection.any",
+                    "v": ["äüö"],
+                }
+            ],
+            "title": "Hello World",
+        }
+        self.assertEqual(
+            encode(data, schema=IQuerySchema),
+            (
+                "query.i%3Arecords=Subject&query.o%3A"
+                "records=plone.app.querystring.operation.selection.any&"
+                "query.v%3Alist%3Arecords=%C3%A4%C3%BC%C3%B6&title=Hello+World"
+            ),
+        )
+
+    def test_encode_unicode_lines(self):
+        data = {"words": ["ä", "ö"]}
+        self.assertEqual(
+            encode(data, schema=IWords), "words%3Alist=%C3%A4&words%3Alist=%C3%B6"
+        )
+
+    def test_skip_encoding_primary_fields(self):
+        data = {"words": ["ä", "ö"]}
+        self.assertEqual(encode(data, schema=IPrimary), "")
+
+
+class TestDecode(unittest.TestCase):
+
+    layer = PLONE_TILES_INTEGRATION_TESTING
+
+    def test_decode_unicode_lines(self):
+        data = {"words": ["ä", "ö"]}
+        self.assertEqual(decode(data, schema=IWords), {"words": ["ä", "ö"]})
+
+    def test_skip_decoding_primary_fields(self):
+        data = {"words": ["ä", "ö"]}
+        self.assertEqual(decode(data, schema=IPrimary), {})

plone/tiles/tests/test_doctests.py

@@ -0,0 +1,30 @@
+from plone.testing import layered
+from plone.tiles.testing import PLONE_TILES_INTEGRATION_TESTING
+
+import doctest
+import re
+import unittest
+
+
+class Py23DocChecker(doctest.OutputChecker):
+    def check_output(self, want, got, optionflags):
+        want = re.sub("u'(.*?)'", "'\\1'", want)
+        return doctest.OutputChecker.check_output(self, want, got, optionflags)
+
+
+def test_suite():
+    return unittest.TestSuite(
+        (
+            layered(
+                doctest.DocFileSuite(
+                    "../tiles.rst",
+                    "../directives.rst",
+                    "../data.rst",
+                    "../esi.rst",
+                    optionflags=doctest.ELLIPSIS,
+                    checker=Py23DocChecker(),
+                ),
+                layer=PLONE_TILES_INTEGRATION_TESTING,
+            ),
+        )
+    )

plone/tiles/tile.py

@@ -0,0 +1,186 @@
+from plone.tiles.interfaces import IPersistentTile
+from plone.tiles.interfaces import ITile
+from plone.tiles.interfaces import ITileDataManager
+from Products.Five import BrowserView
+from zExceptions import Forbidden
+from zope.component import queryMultiAdapter
+from zope.interface import implementer
+from zope.traversing.browser.absoluteurl import absoluteURL
+
+
+@implementer(ITile)
+class Tile(BrowserView):
+    """Basic implementation of a transient tile. Subclasses should override
+    __call__ or set an 'index' variable to point to a view page template file.
+
+    The tile is basically a browser view, with the following enhancements:
+
+    * The attribute `data` can be used to read the tile data, as returned by
+      `ITileDataManager(tile).get()`. This value is cached when it is first
+      read.
+    * The attribute `url` can be used to obtain the tile's URL, including the
+      id specifier and any data associated with a transient tile. Again, the
+      return value is cached after the first access.
+    * The class implements __getitem__() to set the tile id from the traversal
+      sub-path, as well as to allow views to be looked up. This is what allows
+      a URL like `http://.../@@example.tile/foo` to result in a tile with id
+      `foo`.
+    """
+
+    __cachedData = None
+    __cachedURL = None
+
+    id = None
+
+    def __getitem__(self, name):
+
+        # If we haven't set the id yet, do that first
+        if self.id is None:
+            self.id = name
+
+            # This is pretty stupid, but it's required to keep the ZPublisher
+            # happy in Zope 2. It doesn't normally check for docstrings on
+            # views, but it does check for them on sub-objects obtained via
+            # __getitem__.
+
+            if self.__doc__ is None:
+                self.__doc__ = "For Zope 2, to keep the ZPublisher happy"
+
+            # Note: X-Tile-Url was added to make it easier for editor to know
+            # the URL of a new tile after receiving the redirected response
+            # from a tile form. That's why it's only set for customizable tiles
+            # (tiles with id).
+            if self.id is not None:
+                self.request.response.setHeader("X-Tile-Url", self.url)
+
+            return self
+
+        # Also allow views on tiles even without @@.
+        viewName = name
+        if viewName.startswith("@@"):
+            viewName = name[2:]
+        view = queryMultiAdapter((self, self.request), name=viewName)
+        if view is not None:
+            view.__parent__ = self
+            view.__name__ = viewName
+            return view
+
+        raise KeyError(name)
+
+    def browserDefault(self, request):
+        """By default, tiles render themselves with no browser-default view"""
+        return self, ()
+
+    def publishTraverse(self, request, name):
+        """Ensure that publish-traversal uses the same semantics as
+        __getitem__.
+        """
+        return self[name]
+
+    def __call__(self, *args, **kwargs):
+        if getattr(self, "index", None) is None:
+            raise NotImplementedError(
+                'Override __call__ or set a class variable "index" to point '
+                "to a view page template file"
+            )
+        return self.index(*args, **kwargs)
+
+    @property
+    def data(self):
+        if self.__cachedData is None:
+            reader = ITileDataManager(self)
+            self.__cachedData = reader.get()
+        return self.__cachedData
+
+    @property
+    def url(self):
+        return absoluteURL(self, self.request)
+
+
+@implementer(IPersistentTile)
+class PersistentTile(Tile):
+    """Base class for persistent tiles. Identical to `Tile`, except that the
+    data dict is never serialized with the URL.
+    """
+
+
+class TileThemingTransform:
+    """Disable plone.app.theming for tile responses"""
+
+    order = 8800
+
+    def __init__(self, published, request):
+        self.published = published
+        self.request = request
+
+    def transform(self, result, encoding):
+        self.request.response.setHeader("X-Theme-Disabled", "1")
+        return None
+
+    def transformBytes(self, result, encoding):
+        return self.transform(result, encoding)
+
+    def transformUnicode(self, result, encoding):
+        return self.transform(result, encoding)
+
+    def transformIterable(self, result, encoding):
+        return self.transform(result, encoding)
+
+
+class TileProtectTransform:
+    """Replacement transform for plone.protect's ProtectTransform, to drop
+    X-Tile-Url-header from unauthorized responses and disable the default
+    ProtectTransform for authorized responses (to avoid causing issues
+    like extra protect.js-injections for tile editors)
+    """
+
+    order = 9000
+
+    def __init__(self, published, request):
+        self.published = published
+        self.request = request
+        try:
+            from plone.protect.auto import ProtectTransform
+
+            self.protect = ProtectTransform(published, request)
+        except ImportError:
+            self.protect = None
+
+    def transform(self, result, encoding):
+        from plone.protect import CheckAuthenticator
+
+        CheckAuthenticator(self.request)
+        return None
+
+    def transformBytes(self, result, encoding):
+        try:
+            return self.transform(result, encoding)
+        except Forbidden:
+            if "x-tile-url" in self.request.response.headers:
+                del self.request.response.headers["x-tile-url"]
+            if self.protect is not None:
+                return self.protect.transformBytes(result, encoding)
+            else:
+                return None
+
+    def transformUnicode(self, result, encoding):
+        try:
+            return self.transform(result, encoding)
+        except Forbidden:
+            if "x-tile-url" in self.request.response.headers:
+                del self.request.response.headers["x-tile-url"]
+            if self.protect is not None:
+                return self.protect.transformUnicode(result, encoding)
+            else:
+                return None
+
+    def transformIterable(self, result, encoding):
+        try:
+            return self.transform(result, encoding)
+        except Forbidden:
+            if "x-tile-url" in self.request.response.headers:
+                del self.request.response.headers["x-tile-url"]
+            if self.protect is not None:
+                return self.protect.transformIterable(result, encoding)
+            else:
+                return None