collective.behavior.talcondition 1.0a2__py3-none-any.whl

collective/behavior/talcondition/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+"""Init and utils."""
+
+from plone import api
+from zope.i18nmessageid import MessageFactory
+
+
+_ = MessageFactory('collective.behavior.talcondition')
+
+PLONE_VERSION = int(api.env.plone_version()[0])
+
+
+def initialize(context):
+    """Initializer called when used as a Zope 2 product."""

collective/behavior/talcondition/behavior.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+from collective.behavior.talcondition import _
+from collective.behavior.talcondition.utils import evaluateExpressionFor
+from plone.autoform import directives as form
+from plone.autoform.interfaces import IFormFieldProvider
+from plone.dexterity.interfaces import IDexterityContent
+from plone.supermodel import model
+from z3c.form.browser.checkbox import CheckBoxFieldWidget
+from zope import schema
+from zope.component import adapts
+from zope.interface import alsoProvides
+from zope.interface import implementer
+
+
+class ITALCondition(model.Schema):
+
+    form.widget("tal_condition", size=80)
+    tal_condition = schema.TextLine(
+        title=_(u"TAL condition expression"),
+        description=_(
+            u"Enter a TAL expression that once evaluated "
+            "will return 'True' if content should be "
+            "available. Elements 'member', 'context' "
+            "and 'portal' are available for the "
+            "expression."
+        ),
+        required=False,
+        default=u"",
+    )
+
+    form.widget(
+        "roles_bypassing_talcondition",
+        CheckBoxFieldWidget,
+        multiple="multiple",
+        size=15,
+    )
+    roles_bypassing_talcondition = schema.Set(
+        title=_(u"Roles that will bypass the TAL condition"),
+        description=_(
+            u"Choose the different roles for which the TAL "
+            "condition will not be evaluated and always "
+            "considered 'True'."
+        ),
+        required=False,
+        value_type=schema.Choice(vocabulary="plone.app.vocabularies.Roles"),
+    )
+
+    def evaluate(self):
+        """Evaluate the condition and returns True or False."""
+
+
+alsoProvides(ITALCondition, IFormFieldProvider)
+
+
+@implementer(ITALCondition)
+class TALCondition(object):
+    """ """
+
+    adapts(IDexterityContent)
+
+    def __init__(self, context):
+        self.context = context
+
+    def get_tal_condition(self):
+        return getattr(self.context, "tal_condition", "")
+
+    def set_tal_condition(self, value):
+        self.context.tal_condition = value
+
+    tal_condition = property(get_tal_condition, set_tal_condition)
+
+    def get_roles_bypassing_talcondition(self):
+        return getattr(self.context, "roles_bypassing_talcondition", [])
+
+    def set_roles_bypassing_talcondition(self, value):
+        self.context.roles_bypassing_talcondition = value
+
+    roles_bypassing_talcondition = property(
+        get_roles_bypassing_talcondition, set_roles_bypassing_talcondition
+    )
+
+    def complete_extra_expr_ctx(self, extra_expr_ctx):
+        """Complete extra_expr_ctx, this is made to be overrided."""
+        return extra_expr_ctx
+
+    def evaluate(self, extra_expr_ctx={}):
+        extra_expr_ctx = self.complete_extra_expr_ctx(extra_expr_ctx)
+        return evaluateExpressionFor(self, extra_expr_ctx=extra_expr_ctx)

collective/behavior/talcondition/configure.zcml

@@ -0,0 +1,55 @@
+<configure
+    xmlns="http://namespaces.zope.org/zope"
+    xmlns:five="http://namespaces.zope.org/five"
+    xmlns:i18n="http://namespaces.zope.org/i18n"
+    xmlns:plone="http://namespaces.plone.org/plone"
+    xmlns:genericsetup="http://namespaces.zope.org/genericsetup"
+    xmlns:zcml="http://namespaces.zope.org/zcml"
+    i18n_domain="collective.behavior.talcondition">
+
+    <i18n:registerTranslations directory="locales" />
+
+    <five:registerPackage package="." initialize=".initialize" />
+
+    <include package="plone.behavior" file="meta.zcml" />
+    <include package="plone.app.dexterity" />
+
+    <plone:behavior
+        title="TALCondition"
+        description="Add a TAL condition field useable to check if content should be available."
+        provides=".behavior.ITALCondition"
+        for="plone.dexterity.interfaces.IDexterityContent"
+        factory=".behavior.TALCondition"
+        marker=".interfaces.ITALConditionable"
+        />
+
+    <adapter zcml:condition="not-have plone-5"
+             factory=".extender.TALConditionExtender"
+             for=".interfaces.ITALConditionable"
+             provides="archetypes.schemaextender.interfaces.ISchemaExtender"
+             name="collective.behavior.talcondition.extender" />
+
+    <genericsetup:registerProfile
+        name="default"
+        title="collective.behavior.talcondition"
+        directory="profiles/default"
+        description="Installs the collective.behavior.talcondition add-on."
+        provides="Products.GenericSetup.interfaces.EXTENSION"
+        />
+
+    <genericsetup:registerProfile
+        name="uninstall"
+        title="collective.behavior.talcondition"
+        directory="profiles/uninstall"
+        description="Uninstalls the collective.behavior.talcondition add-on."
+        provides="Products.GenericSetup.interfaces.EXTENSION"
+        />
+
+    <genericsetup:importStep
+        name="collective.behavior.talcondition-postInstall"
+        title="collective.behavior.talcondition post_install import step"
+        description="Post install import step from collective.behavior.talcondition"
+        handler=".setuphandlers.post_install">
+    </genericsetup:importStep>
+
+</configure>

collective/behavior/talcondition/extender.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+from archetypes.schemaextender.field import ExtensionField
+from archetypes.schemaextender.interfaces import IBrowserLayerAwareExtender
+from archetypes.schemaextender.interfaces import ISchemaExtender
+from collective.behavior.talcondition.interfaces import ICollectiveBehaviorTalconditionLayer
+from collective.behavior.talcondition.interfaces import ITALConditionable
+from Products.Archetypes.public import LinesField
+from Products.Archetypes.public import MultiSelectionWidget
+from Products.Archetypes.public import StringField
+from Products.Archetypes.public import StringWidget
+from zope.component import adapts
+from zope.interface import implementer
+
+
+class TALConditionStringField(ExtensionField, StringField):
+    """A string field that will contain an eventual TAL condition expression."""
+
+
+class TALConditionLinesField(ExtensionField, LinesField):
+    """A Lines field that will contain all roles
+       that will bypass the tal condition."""
+
+
+@implementer(ISchemaExtender, IBrowserLayerAwareExtender)
+class TALConditionExtender(object):
+    """TALCondition class"""
+
+    adapts(ITALConditionable)
+
+    layer = ICollectiveBehaviorTalconditionLayer
+
+    fields = [
+        TALConditionStringField(
+            'tal_condition',
+            required=False,
+            default='',
+            searchable=False,
+            languageIndependent=True,
+            widget=StringWidget(
+                label=(u"TAL condition expression"),
+                description=(u'Enter a TAL expression that once evaluated '
+                             'will return \'True\' if content should be '
+                             'available. Elements \'member\', \'context\' '
+                             'and \'portal\' are available for the '
+                             'expression.'),
+                i18n_domain='collective.behavior.talcondition',
+                size="80",
+            ),
+        ),
+        TALConditionLinesField(
+            'roles_bypassing_talcondition',
+            required=False,
+            searchable=False,
+            languageIndependent=True,
+            widget=MultiSelectionWidget(
+                size=10,
+                label=(u'Roles that will bypass the TAL condition'),
+                description=(u'Choose the different roles for which the TAL '
+                             'condition will not be evaluated and always '
+                             'considered \'True\'.'
+                             ),
+                i18n_domain='collective.behavior.talcondition',
+            ),
+            enforceVocabulary=True,
+            multiValued=1,
+            vocabulary_factory='plone.app.vocabularies.Roles',
+        ),
+    ]
+
+    def __init__(self, context):
+        self.context = context
+
+    def getFields(self):
+        return self.fields

collective/behavior/talcondition/interfaces.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""Module where all interfaces, events and exceptions live."""
+
+from zope.interface import Interface
+from zope.publisher.interfaces.browser import IDefaultBrowserLayer
+
+
+class ICollectiveBehaviorTalconditionLayer(IDefaultBrowserLayer):
+    """Marker interface that defines a browser layer."""
+
+
+class ITALConditionable(Interface):
+    """
+    Marker interface for tal_condition field schema extender
+    """

collective/behavior/talcondition/locales/es/LC_MESSAGES/collective.behavior.talcondition.po

@@ -0,0 +1,35 @@
+# Translation of collective.behavior.talcondition.pot to Spanish
+# Leonardo J. Caballero G. <leonardocaballero@gmail.com>, 2020.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: collective.behavior.talcondition\n"
+"POT-Creation-Date: 2015-06-05 07:17+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI +ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=1; plural=0\n"
+"Language-Code: es\n"
+"Language-Name: Spanish\n"
+"Preferred-Encodings: utf-8 latin1\n"
+"Domain: collective.behavior.talcondition\n"
+"X-Is-Fallback-For: es-ar es-bo es-cl es-co es-cr es-do es-ec es-es es-sv es-gt es-hn es-mx es-ni es-pa es-py es-pe es-pr es-us es-uy es-ve\n"
+
+#: ../behavior.py:28
+msgid "Choose the different roles for which the TAL condition will not be evaluated and always considered 'True'."
+msgstr "Seleccione los roles para los cuales la condición TAL no se evaluará y siempre será 'True'."
+
+#: ../behavior.py:17
+msgid "Enter a TAL expression that once evaluated will return 'True' if content should be available. Elements 'member', 'context' and 'portal' are available for the expression."
+msgstr "Ingrese una expresión TAL que, cuando se evalúe, devolverá 'True' si el elemento va a estar disponible. Los elementos 'member', 'context' y 'portal' están disponibles en la expresión."
+
+#: ../behavior.py:27
+msgid "Roles that will bypass the TAL condition"
+msgstr "Roles que omiten la expresión TAL"
+
+#: ../behavior.py:16
+msgid "TAL condition expression"
+msgstr "Condición en formato TAL"

collective/behavior/talcondition/locales/fr/LC_MESSAGES/collective.behavior.talcondition.po

@@ -0,0 +1,31 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2015-06-05 07:17+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI +ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=1; plural=0\n"
+"Language-Code: en\n"
+"Language-Name: English\n"
+"Preferred-Encodings: utf-8 latin1\n"
+"Domain: DOMAIN\n"
+
+#: ../behavior.py:28
+msgid "Choose the different roles for which the TAL condition will not be evaluated and always considered 'True'."
+msgstr "Sélectionnez les rôles pour lesquels la condition TAL ne sera pas évaluée et sera toujours 'vraie'."
+
+#: ../behavior.py:17
+msgid "Enter a TAL expression that once evaluated will return 'True' if content should be available. Elements 'member', 'context' and 'portal' are available for the expression."
+msgstr "Entrez une expression TAL qui une fois évaluée, retournera 'Vrai' si l'élément doit être disponible.  Les éléments 'member', 'context' et 'portal' sont disponibles dans l'expression."
+
+#: ../behavior.py:27
+msgid "Roles that will bypass the TAL condition"
+msgstr "Rôles qui by-passent l'expression TAL"
+
+#: ../behavior.py:16
+msgid "TAL condition expression"
+msgstr "Condition au format TAL"

collective/behavior/talcondition/profiles/default/browserlayer.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<layers>
+  <layer
+    name="collective.behavior.talcondition"
+    interface="collective.behavior.talcondition.interfaces.ICollectiveBehaviorTalconditionLayer"
+  />
+</layers>

collective/behavior/talcondition/profiles/default/metadata.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<metadata>
+  <version>1</version>
+</metadata>

collective/behavior/talcondition/profiles/testing/metadata.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<metadata>
+  <version>1</version>
+  <dependencies>
+    <dependency>profile-collective.behavior.talcondition:default</dependency>
+  </dependencies>
+</metadata>

collective/behavior/talcondition/profiles/testing/types/testtype.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+<object name="testtype" meta_type="Dexterity FTI" i18n:domain="plone"
+   xmlns:i18n="http://xml.zope.org/namespaces/i18n">
+ <property name="title" i18n:translate="">Test type</property>
+ <property name="description" i18n:translate="">None</property>
+ <property name="icon_expr">string:${portal_url}/folder_icon.png</property>
+ <property name="factory">testtype</property>
+ <property name="add_view_expr">string:${folder_url}/++add++testtype</property>
+ <property name="link_target"></property>
+ <property name="immediate_view">view</property>
+ <property name="global_allow">True</property>
+ <property name="filter_content_types">True</property>
+ <property name="allowed_content_types" />
+ <property name="allow_discussion">False</property>
+ <property name="default_view">view</property>
+ <property name="view_methods">
+  <element value="view"/>
+ </property>
+ <property name="default_view_fallback">False</property>
+ <property name="add_permission">cmf.AddPortalContent</property>
+ <property name="behaviors">
+ 	<element value="collective.behavior.talcondition.behavior.ITALCondition" />
+ </property>
+ <property name="schema" />
+ <!-- DO NOT use a model_source or it removes manually added fields while reapplying the profile -->
+ <!--property name="model_source" /-->
+ <alias from="(Default)" to="(dynamic view)"/>
+ <alias from="edit" to="@@edit"/>
+ <alias from="sharing" to="@@sharing"/>
+ <alias from="view" to="(selected layout)"/>
+ <action title="View" action_id="view" category="object" condition_expr=""
+    description="" icon_expr="" link_target="" url_expr="string:${object_url}"
+    visible="True">
+  <permission value="View"/>
+ </action>
+ <action title="Edit" action_id="edit" category="object" condition_expr=""
+    description="" icon_expr="" link_target=""
+    url_expr="string:${object_url}/edit" visible="True">
+  <permission value="Modify portal content"/>
+ </action>
+</object>

collective/behavior/talcondition/profiles/testing/types.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<object name="portal_types" meta_type="Plone Types Tool">
+<property name="title">Controls the available content types in your portal</property>
+<object name="testtype" meta_type="Dexterity FTI"/>
+</object>

collective/behavior/talcondition/profiles/uninstall/browserlayer.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<layers>
+  <layer
+    name="collective.behavior.talcondition"
+    interface="collective.behavior.talcondition.interfaces.ICollectiveBehaviorTalconditionLayer" remove="True"
+  />
+</layers>

collective/behavior/talcondition/setuphandlers.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+
+def isNotCurrentProfile(context):
+    return context.readDataFile("collectivebehaviortalcondition_marker.txt") is None
+
+
+def post_install(context):
+    """Post install script"""
+    if isNotCurrentProfile(context):
+        return

collective/behavior/talcondition/testing.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""Base module for unittesting."""
+
+from collective.behavior.talcondition import PLONE_VERSION
+from plone import api
+from plone.app.robotframework.testing import AUTOLOGIN_LIBRARY_FIXTURE
+from plone.app.testing import applyProfile
+from plone.app.testing import FunctionalTesting
+from plone.app.testing import IntegrationTesting
+from plone.app.testing import login
+from plone.app.testing import PLONE_FIXTURE
+from plone.app.testing import PloneSandboxLayer
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from plone.app.testing import TEST_USER_NAME
+from plone.testing import z2
+
+import collective.behavior.talcondition
+import unittest
+
+
+class CollectiveBehaviorTalconditionLayer(PloneSandboxLayer):
+
+    defaultBases = (PLONE_FIXTURE,)
+    products = ("collective.behavior.talcondition",)
+
+    def setUpZope(self, app, configurationContext):
+        """Set up Zope."""
+        # Load ZCML
+        self.loadZCML(package=collective.behavior.talcondition, name="testing.zcml")
+        for p in self.products:
+            z2.installProduct(app, p)
+
+    def setUpPloneSite(self, portal):
+        """Set up Plone."""
+        # Set default chain for plone.app.contenttypes
+        wftool = portal["portal_workflow"]
+        wftool.setDefaultChain("simple_publication_workflow")
+
+        # Install into Plone
+        if PLONE_VERSION < 5:
+            installer = portal["portal_quickinstaller"]
+            installer.installProduct("collective.behavior.talcondition")
+        applyProfile(portal, "collective.behavior.talcondition:testing")
+
+        try:
+            applyProfile(portal, "plone.app.contenttypes:plone-content")
+        except KeyError:
+            # BBB Plone 4
+            pass
+
+        # Login and create some test content
+        setRoles(portal, TEST_USER_ID, ["Manager"])
+        login(portal, TEST_USER_NAME)
+        api.content.create(container=portal, type="Folder", id="folder")
+
+        # Commit so that the test browser sees these objects
+        import transaction
+
+        transaction.commit()
+
+    def tearDownZope(self, app):
+        """Tear down Zope."""
+        for p in reversed(self.products):
+            z2.uninstallProduct(app, p)
+
+
+FIXTURE = CollectiveBehaviorTalconditionLayer(name="FIXTURE")
+
+
+INTEGRATION = IntegrationTesting(bases=(FIXTURE,), name="INTEGRATION")
+
+
+FUNCTIONAL = FunctionalTesting(bases=(FIXTURE,), name="FUNCTIONAL")
+
+
+ACCEPTANCE = FunctionalTesting(
+    bases=(FIXTURE, AUTOLOGIN_LIBRARY_FIXTURE, z2.ZSERVER_FIXTURE), name="ACCEPTANCE"
+)
+
+
+class IntegrationTestCase(unittest.TestCase):
+    """Base class for integration tests."""
+
+    layer = INTEGRATION
+
+    def setUp(self):
+        super(IntegrationTestCase, self).setUp()
+        self.portal = self.layer["portal"]
+
+
+class FunctionalTestCase(unittest.TestCase):
+    """Base class for functional tests."""
+
+    layer = FUNCTIONAL

collective/behavior/talcondition/testing.zcml

@@ -0,0 +1,21 @@
+<configure
+    xmlns="http://namespaces.zope.org/zope"
+    xmlns:genericsetup="http://namespaces.zope.org/genericsetup"
+    xmlns:zcml="http://namespaces.zope.org/zcml"
+    i18n_domain="collective.behavior.talcondition">
+
+  <include file="configure.zcml" />
+
+  <class zcml:condition="not-have plone-5"
+         class="Products.ATContentTypes.content.document.ATDocument">
+    <implements interface="collective.behavior.talcondition.interfaces.ITALConditionable" />
+  </class>
+
+  <genericsetup:registerProfile
+      name="testing"
+      title="collective.behavior.talcondition tests"
+      directory="profiles/testing"
+      description="Steps to ease tests of collective.behavior.talcondition"
+      provides="Products.GenericSetup.interfaces.EXTENSION" />
+
+</configure>

collective/behavior/talcondition/tests/test_behavior.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+from collective.behavior.talcondition import PLONE_VERSION
+from collective.behavior.talcondition.behavior import ITALCondition
+from collective.behavior.talcondition.interfaces import ITALConditionable
+from collective.behavior.talcondition.testing import IntegrationTestCase
+from plone.app.testing import login
+from plone.app.testing import TEST_USER_NAME
+
+
+class TestBehavior(IntegrationTestCase):
+
+    def setUp(self):
+        """ """
+        super(TestBehavior, self).setUp()
+        # create a testitem
+        login(self.portal, TEST_USER_NAME)
+        self.portal.invokeFactory(id='testitem',
+                                  type_name='testtype',
+                                  title='Test type')
+        self.testitem = self.portal.testitem
+        self.adapted = ITALCondition(self.testitem)
+
+    def test_behavior(self):
+        """Test that once enabled, the behavior do the job."""
+        if PLONE_VERSION < 5:
+            # in Plone 4, a behavior attribute is not set (until saved ?)
+            self.assertFalse(hasattr(self.testitem, 'tal_condition'))
+        # it has a 'tal_condition' attribute
+        self.assertTrue(hasattr(self.adapted, 'tal_condition'))
+        self.assertTrue(ITALConditionable.providedBy(self.portal.testitem))
+        # set a tal_condition and evaluate
+        # this is True
+        self.adapted.tal_condition = u"python:context.portal_type=='testtype'"
+        self.assertTrue(self.adapted.evaluate())
+        # this is False
+        self.adapted.tal_condition = u"python:context.portal_type=='unexisting_portal_type'"
+        self.assertFalse(self.adapted.evaluate())
+
+    def test_wrong_condition(self):
+        """In case the condition is wrong, it just returns False
+           and a message is added to the Zope log."""
+        # using a wrong expression does not break anything
+        self.adapted.tal_condition = u'python: context.some_unexisting_method()'
+        self.assertFalse(self.adapted.evaluate())
+
+    def test_evaluate_extra_expr_ctx(self):
+        """The 'evaluate' method can receive a 'extra_expr_ctx' dict
+           that will extend the TAL expression context."""
+        self.adapted.tal_condition = "python: value == '122'"
+        self.assertFalse(self.adapted.evaluate())
+        self.assertTrue(self.adapted.evaluate(extra_expr_ctx={'value': '122'}))

collective/behavior/talcondition/tests/test_extender.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from collective.behavior.talcondition import PLONE_VERSION
+from collective.behavior.talcondition.interfaces import ITALConditionable
+from collective.behavior.talcondition.testing import IntegrationTestCase
+from collective.behavior.talcondition.utils import evaluateExpressionFor
+from plone.app.testing import login
+from plone.app.testing import TEST_USER_NAME
+
+import unittest
+
+
+class TestExtender(IntegrationTestCase):
+
+    @unittest.skipIf(PLONE_VERSION >= 5, 'Archetypes extender test skipped in Plone 5')
+    def test_extender(self):
+        """The extender is enabled on ATDocument in testing.zcml.
+           Check that 'tal_condition' is available."""
+        login(self.portal, TEST_USER_NAME)
+        self.portal.invokeFactory(id='doc',
+                                  type_name='Document',
+                                  title='Test document')
+        doc = self.portal.doc
+        self.assertTrue(ITALConditionable.providedBy(doc))
+        # set a tal_condition and evaluate
+        # this is True
+        doc.tal_condition = u"python:context.portal_type=='Document'"
+        self.assertTrue(evaluateExpressionFor(doc))
+        # this is False
+        doc.tal_condition = u"python:context.portal_type=='unexisting_portal_type'"
+        self.assertFalse(evaluateExpressionFor(doc))

collective/behavior/talcondition/tests/test_robot.py

@@ -0,0 +1,24 @@
+from ..testing import ACCEPTANCE
+from plone.testing import layered
+
+import os
+import robotsuite
+import unittest
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    current_dir = os.path.abspath(os.path.dirname(__file__))
+    robot_dir = os.path.join(current_dir, 'robot')
+    robot_tests = [
+        os.path.join('robot', doc) for doc in os.listdir(robot_dir)
+        if doc.endswith('.robot') and doc.startswith('test_')
+    ]
+    for test in robot_tests:
+        suite.addTests([
+            layered(
+                robotsuite.RobotTestSuite(test),
+                layer=ACCEPTANCE
+            ),
+        ])
+    return suite

collective/behavior/talcondition/tests/test_setup.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""Setup/installation tests for this package."""
+from collective.behavior.talcondition import PLONE_VERSION
+from collective.behavior.talcondition.testing import IntegrationTestCase
+from plone import api
+
+
+if PLONE_VERSION >= 5:
+    from Products.CMFPlone.utils import get_installer
+
+
+class TestInstall(IntegrationTestCase):
+    """Test installation of collective.behavior.talcondition into Plone."""
+
+    def setUp(self):
+        """Custom shared utility setup for tests."""
+        self.portal = self.layer["portal"]
+        if PLONE_VERSION < 5:
+            self.installer = api.portal.get_tool("portal_quickinstaller")
+        else:
+            self.installer = get_installer(self.portal, self.layer["request"])
+
+    def test_product_installed(self):
+        """Test if collective.behavior.talcondition is installed with portal_quickinstaller."""
+        if PLONE_VERSION < 5:
+            self.assertTrue(
+                self.installer.isProductInstalled("collective.behavior.talcondition")
+            )
+        else:
+            self.assertTrue(
+                self.installer.is_product_installed("collective.behavior.talcondition")
+            )
+
+    # browserlayer.xml
+    def test_browserlayer(self):
+        """Test that ICollectiveBehaviorTalconditionLayer is registered."""
+        from collective.behavior.talcondition.interfaces import ICollectiveBehaviorTalconditionLayer
+        from plone.browserlayer import utils
+
+        self.assertIn(ICollectiveBehaviorTalconditionLayer, utils.registered_layers())
+
+
+class TestUninstall(IntegrationTestCase):
+    def setUp(self):
+        """Custom shared utility setup for tests."""
+        self.portal = self.layer["portal"]
+        if PLONE_VERSION < 5:
+            self.installer = api.portal.get_tool("portal_quickinstaller")
+            self.installer.uninstallProducts(["collective.behavior.talcondition"])
+        else:
+            self.installer = get_installer(self.portal, self.layer["request"])
+            self.installer.uninstall_product("collective.behavior.talcondition")
+
+    def test_uninstall(self):
+        """Test if collective.behavior.talcondition is cleanly uninstalled."""
+        if PLONE_VERSION < 5:
+            self.assertFalse(
+                self.installer.isProductInstalled("collective.behavior.talcondition")
+            )
+        else:
+            self.assertFalse(
+                self.installer.is_product_installed("collective.behavior.talcondition")
+            )

collective/behavior/talcondition/tests/test_utils.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+
+from AccessControl import Unauthorized
+from collective.behavior.talcondition import PLONE_VERSION
+from collective.behavior.talcondition.behavior import ITALCondition
+from collective.behavior.talcondition.interfaces import ITALConditionable
+from collective.behavior.talcondition.testing import IntegrationTestCase
+from collective.behavior.talcondition.utils import _evaluateExpression
+from collective.behavior.talcondition.utils import applyExtender
+from collective.behavior.talcondition.utils import evaluateExpressionFor
+from plone.app.testing import login
+from plone.app.testing import TEST_USER_NAME
+from zope.interface import alsoProvides
+
+import unittest
+
+
+class TestUtils(IntegrationTestCase):
+
+    def setUp(self):
+        """ """
+        super(TestUtils, self).setUp()
+        # create a testitem
+        login(self.portal, TEST_USER_NAME)
+        self.portal.invokeFactory(id='testitem',
+                                  type_name='testtype',
+                                  title='Test type')
+        self.adapted = ITALCondition(self.portal.testitem)
+
+    def test_wrong_condition(self):
+        """In case the condition is wrong, it just returns False
+           and a message is added to the Zope log."""
+        # using a wrong expression does not break anything
+        self.adapted.tal_condition = u'python: context.some_unexisting_method()'
+        self.assertFalse(self.adapted.evaluate())
+
+    @unittest.skipIf(PLONE_VERSION >= 5, 'Archetypes extender test skipped in Plone 5')
+    def test_apply_extender(self):
+        """Test that existing objects are correctly updated
+           after enabling extender for their meta_type."""
+        # the extender is not enabled for "Folder"
+        login(self.portal, TEST_USER_NAME)
+        self.portal.invokeFactory(id='testfolder',
+                                  type_name='Folder',
+                                  title='Test folder')
+        testfolder = self.portal.testfolder
+        self.assertFalse(hasattr(testfolder, 'tal_condition'))
+        self.assertFalse(ITALConditionable.providedBy(testfolder))
+        # enable the extender for testfolder
+        alsoProvides(testfolder, ITALConditionable)
+        # the schema is not updated until we do it
+        self.assertFalse(hasattr(testfolder, 'tal_condition'))
+        applyExtender(self.portal, meta_types=('ATFolder', ))
+        # now the field is available
+        self.assertTrue(hasattr(testfolder, 'tal_condition'))
+
+    def test_empty_condition(self):
+        # using an empty expression is considered True
+        self.adapted.tal_condition = None
+        self.assertTrue(self.adapted.evaluate())
+
+    def test_bypass_for_manager(self):
+        """In this case, no matter the expression is False,
+           it will return True if current user is 'Manager'."""
+        # using a wrong expression does not break anything
+        self.adapted.tal_condition = "python:False"
+        self.assertFalse(evaluateExpressionFor(self.adapted))
+        self.adapted.roles_bypassing_talcondition = [u'Manager']
+        # as current user is Manager, he can bypass the expression result
+        self.assertTrue(evaluateExpressionFor(self.adapted))
+
+    def test_extra_expr_ctx(self):
+        """It is possible to pass extra values that will be available
+           in the context of the expression."""
+        self.adapted.tal_condition = "python: value == '122'"
+        self.assertFalse(evaluateExpressionFor(self.adapted))
+        self.assertTrue(evaluateExpressionFor(self.adapted, {'value': '122'}))
+
+    def test_empty_expr_is_true(self):
+        """Test parameter used by utils._evaluateExpression making an empty
+           expression to be considered True or False."""
+        # True by default
+        self.assertTrue(_evaluateExpression(self.portal,
+                                            expression=''))
+        self.assertTrue(_evaluateExpression(self.portal,
+                                            expression=None))
+        self.assertFalse(_evaluateExpression(self.portal,
+                                             expression='',
+                                             empty_expr_is_true=False))
+        self.assertFalse(_evaluateExpression(self.portal,
+                                             expression=None,
+                                             empty_expr_is_true=False))
+
+    def test_raise_on_error(self):
+        """By default, a wrong expression will return False, except if raise_on_error=True,
+           in this case the exception will be raised."""
+        self.adapted.tal_condition = u'python: context.some_unexisting_method()'
+        self.assertFalse(evaluateExpressionFor(self.adapted))
+        self.assertRaises(AttributeError, evaluateExpressionFor, self.adapted, raise_on_error=True)
+
+    def test_trusted(self):
+        self.assertRaises(Unauthorized,
+                          _evaluateExpression,
+                          self.portal,
+                          expression='python: context.unrestrictedTraverse("view")',
+                          raise_on_error=True)
+        self.assertTrue(_evaluateExpression(
+            self.portal,
+            expression='python: context.unrestrictedTraverse("view")',
+            raise_on_error=True,
+            trusted=True))

collective/behavior/talcondition/utils.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+
+from AccessControl.class_init import InitializeClass
+from collective.behavior.talcondition import PLONE_VERSION
+from plone import api
+from Products.CMFCore.Expression import createExprContext
+from Products.CMFCore.Expression import Expression
+from Products.PageTemplates.Expressions import createTrustedZopeEngine
+from Products.PageTemplates.Expressions import SecureModuleImporter
+
+import logging
+import unittest
+
+
+logger = logging.getLogger("collective.behavior.talcondition")
+WRONG_TAL_CONDITION = (
+    "The TAL expression '{0}' for element at '{1}' is wrong.  Original exception : {2}"
+)
+
+
+def evaluateExpressionFor(
+    obj,
+    extra_expr_ctx={},
+    error_pattern=WRONG_TAL_CONDITION,
+    raise_on_error=False,
+    trusted=False,
+):
+    """Evaluate the expression stored in 'tal_condition' of given p_obj."""
+    # get tal_condition
+    tal_condition = obj.tal_condition and obj.tal_condition.strip() or ""
+
+    roles_bypassing_talcondition = obj.roles_bypassing_talcondition
+
+    if hasattr(obj, "context"):
+        obj = obj.context
+    return _evaluateExpression(
+        obj,
+        expression=tal_condition,
+        roles_bypassing_expression=roles_bypassing_talcondition,
+        extra_expr_ctx=extra_expr_ctx,
+        error_pattern=error_pattern,
+        raise_on_error=raise_on_error,
+        trusted=trusted,
+    )
+
+
+def _evaluateExpression(
+    obj,
+    expression,
+    roles_bypassing_expression=[],
+    extra_expr_ctx={},
+    empty_expr_is_true=True,
+    error_pattern=WRONG_TAL_CONDITION,
+    raise_on_error=False,
+    trusted=False,
+):
+    """Evaluate given p_expression extending expression context with p_extra_expr_ctx."""
+    if not expression or not expression.strip():
+        return empty_expr_is_true
+
+    res = True
+    member = api.user.get_current()
+    for role in roles_bypassing_expression or []:
+        if member.has_role(str(role), obj):
+            return res
+    portal = api.portal.get()
+    if trusted:
+        ctx = createTrustedExprContext(obj.aq_inner.aq_parent, portal, obj)
+        expr_handler = TrustedExpression
+    else:
+        ctx = createExprContext(obj.aq_inner.aq_parent, portal, obj)
+        expr_handler = Expression
+    ctx.setGlobal("member", member)
+    ctx.setGlobal("context", obj)
+    ctx.setGlobal("portal", portal)
+    for extra_key, extra_value in list(extra_expr_ctx.items()):
+        ctx.setGlobal(extra_key, extra_value)
+
+    if raise_on_error:
+        res = expr_handler(expression)(ctx)
+    else:
+        try:
+            res = expr_handler(expression)(ctx)
+        except Exception as e:
+            logger.warn(error_pattern.format(expression, obj.absolute_url(), str(e)))
+            res = False
+    return res
+
+
+def createTrustedExprContext(folder, portal, object):
+    """
+    Expression evaluator trusted (not restricted python)
+    Same as createExprContext but use the trusted engine.
+    """
+    pm = api.portal.get_tool("portal_membership")
+    if object is None:
+        object_url = ""
+    else:
+        object_url = object.absolute_url()
+    if pm.isAnonymousUser():
+        member = None
+    else:
+        member = pm.getAuthenticatedMember()
+    data = {
+        "object_url": object_url,
+        "folder_url": folder.absolute_url(),
+        "portal_url": portal.absolute_url(),
+        "object": object,
+        "folder": folder,
+        "portal": portal,
+        "nothing": None,
+        "request": getattr(portal, "REQUEST", None),
+        "modules": SecureModuleImporter,
+        "member": member,
+        "here": object,
+    }
+    return getTrustedEngine().getContext(data)
+
+
+_trusted_engine = createTrustedZopeEngine()
+
+
+def getTrustedEngine():
+    """ """
+    return _trusted_engine
+
+
+class TrustedExpression(Expression):
+    """ """
+
+    text = ""
+    _v_compiled = None
+
+    def __init__(self, text):
+        self.text = text
+        if text.strip():
+            self._v_compiled = getTrustedEngine().compile(text)
+
+    def __call__(self, econtext):
+        if not self.text.strip():
+            return ""
+        compiled = self._v_compiled
+        if compiled is None:
+            compiled = self._v_compiled = getTrustedEngine().compile(self.text)
+        # ?? Maybe expressions should manipulate the security
+        # context stack.
+        res = compiled(econtext)
+        if isinstance(res, Exception):
+            raise res
+        return res
+
+
+InitializeClass(Expression)
+
+
+@unittest.skipIf(PLONE_VERSION >= 5, "Archetypes extender skipped in Plone 5")
+def applyExtender(portal, meta_types):
+    """
+    We add some fields using archetypes.schemaextender to every given p_meta_types.
+    """
+    logger.info(
+        "Adding talcondition fields : updating the schema for meta_types %s"
+        % ",".join(meta_types)
+    )
+    at_tool = api.portal.get_tool("archetype_tool")
+    catalog = api.portal.get_tool("portal_catalog")
+    catalog.ZopeFindAndApply(
+        portal,
+        obj_metatypes=meta_types,
+        search_sub=True,
+        apply_func=at_tool._updateObject,
+    )
+    logger.info("Done!")

collective.behavior.talcondition-1.0a2-py3.11-nspkg.pth

@@ -0,0 +1,2 @@
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('collective',));importlib = __import__('importlib.util');__import__('importlib.machinery');m = sys.modules.setdefault('collective', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('collective', [os.path.dirname(p)])));m = m or sys.modules.setdefault('collective', types.ModuleType('collective'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('collective', 'behavior'));importlib = __import__('importlib.util');__import__('importlib.machinery');m = sys.modules.setdefault('collective.behavior', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('collective.behavior', [os.path.dirname(p)])));m = m or sys.modules.setdefault('collective.behavior', types.ModuleType('collective.behavior'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p);m and setattr(sys.modules['collective'], 'behavior', m)

collective.behavior.talcondition-1.0a2.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.1
+Name: collective.behavior.talcondition
+Version: 1.0a2
+Summary: This package contains a Dexterity behavior and AT schemaextender to add a TAL condition on a content type.
+Home-page: http://pypi.python.org/pypi/collective.behavior.talcondition
+Author: IMIO
+Author-email: dev@imio.be
+License: GPL V2
+Keywords: Python Zope Plone
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Plone
+Classifier: Framework :: Plone :: Addon
+Classifier: Framework :: Plone :: 4.3
+Classifier: Framework :: Plone :: 5.0
+Classifier: Framework :: Plone :: 5.1
+Classifier: Framework :: Plone :: 5.2
+Classifier: Framework :: Plone :: 6.0
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Requires-Dist: plone.api
+Requires-Dist: setuptools
+Requires-Dist: plone.app.dexterity
+Provides-Extra: test
+Requires-Dist: plone.app.testing ; extra == 'test'
+Requires-Dist: plone.app.robotframework ; extra == 'test'
+
+.. image:: https://travis-ci.org/collective/collective.behavior.talcondition.svg?branch=master
+    :target: https://travis-ci.org/collective/collective.behavior.talcondition
+
+.. image:: https://coveralls.io/repos/collective/collective.behavior.talcondition/badge.png
+  :target: https://coveralls.io/r/collective/collective.behavior.talcondition
+
+
+==========================================================================
+collective.behavior.talcondition
+==========================================================================
+
+This package works for dexterity (behavior) and archetypes (schema extender).
+
+It adds two fields on a content type or class:
+
+* tal_condition : enter a `TAL expression <http://docs.zope.org/zope2/zope2book/AppendixC.html>`_ that once evaluated will return 'True' if content should be available. By default, elements 'member', 'context' and 'portal' are available for the expression but the TAL expression context may be extended using the 'extra_expr_ctx' parameter.
+
+* roles_bypassing_talcondition : choose the different roles for which the TAL condition will not be evaluated and always considered \'True\'
+
+It's then possible to use the 'evaluate' method to test the TAL condition.
+
+How to use it
+=============
+
+For AT you have to provide the ITALConditionable on your class (see testing.zcml).
+
+For DX you just have to activate the behavior on your content type.
+
+Plone versions
+==============
+It has been developed and tested for Plone 4 and 5.
+
+
+Translations
+============
+
+This product has been translated into
+
+- French.
+
+- Spanish.
+
+You can contribute for any message missing or other new languages, join us at `Plone Collective Team <https://www.transifex.com/plone/plone-collective/>`_ into *Transifex.net* service with all world Plone translators community.
+
+
+
+Changelog
+=========
+
+
+1.0a2 (2024-09-16)
+------------------
+
+- Fix dict iteration for Python 3
+  [laulaz]
+- Updated Makefile
+  [sgeulette]
+- Used pyenv in gha
+  [sgeulette]
+
+1.0a1 (2023-06-21)
+------------------
+
+- Fix deprecated import AccessControl.class_init instead of App.class_init
+  (Plone6 compatibility)
+  [boulch]
+- Set simplier setup with Makefile
+  [sgeulette]
+
+0.14 (2021-06-29)
+-----------------
+
+- Fix pypi broken package
+  [boulch]
+
+
+0.13 (2021-06-29)
+-----------------
+
+- Add uninstall profile
+  [boulch]
+- Add Plone6 compatibily
+  [boulch]
+
+
+0.12 (2021-04-20)
+-----------------
+
+- Add Transifex.net service integration to manage the translation process.
+  [macagua]
+- Add Spanish translation
+  [macagua]
+- Do not consider the `archetypes.schemaextender` on Plone5.
+  [gbastien]
+- Adapted code (except, implementer) to be Python3 compatible.
+  [gbastien]
+- Added parameter `trusted=False` to `utils._evaluateExpression`, this will use
+  a trusted expression handler instead the restricted python default.
+  [gbastien]
+
+0.11 (2019-05-16)
+-----------------
+
+- Added parameter `raise_on_error` to `utils.evaluateExpressionFor` to raise an
+  error when an exception occurs instead returning False.
+  [gbastien]
+- Added method `TALCondition.complete_extra_expr_ctx` to the behavior to
+  formalize the way to get `extra_expr_ctx` to avoid the `evaluate` method
+  to be overrided.
+  [gbastien]
+
+0.10 (2018-11-20)
+-----------------
+
+- Do not break if parameter `expression` passed to
+  `utils._evaluateExpression` is None.
+  [gbastien]
+
+0.9 (2018-10-12)
+----------------
+
+- Added new parameter `error_pattern=WRONG_TAL_CONDITION` to
+  `utils.evaluateExpressionFor` and underlying `utils._evaluateExpression` to
+  be able to log a custom message in case an error occurs during
+  expression evaluation.
+  [gbastien]
+
+0.8 (2018-06-12)
+----------------
+
+- Mark elements using behavior with `ITALConditionable` interface so it behaves
+  like element using the AT extender.
+  [gbastien]
+
+0.7 (2017-03-22)
+----------------
+
+- Use CheckBoxWidget for `ITALCondition.roles_bypassing_talcondition` to ease
+  selection when displaying several elements.
+  [gbastien]
+
+0.6 (2016-01-12)
+----------------
+
+- Added parameter `empty_expr_is_true` to utils._evaluateExpression than may be True
+  or False depending that we want an empty expression to be considered True or False.
+  Previous behavior is kept in utils.evaluateExpressionFor where an empty expression
+  is considered True.  This avoid managing an empty expression in the caller method
+  [gbastien]
+
+
+0.5 (2015-12-17)
+----------------
+
+- Added method utils._evaluateExpression that receives an expression
+  to evaluate, it is called by utils.evaluateExpressionFor.  This way, this
+  method may evaluate a TAL expression without getting it from the `tal_condition`
+  attribute on the context, in case we want to evaluate arbitrary expression
+  [gbastien]
+
+
+0.4 (2015-09-16)
+----------------
+
+- Make the tal_condition field larger (from 30 to 80) for the
+  AT extender as well as for the DX behavior
+  [gbastien]
+- Added possibility to extend TAL expression context by passing
+  an `extra_expr_ctx` dict to utils.evaluateExpressionFor, also
+  integrated to the `evaluate` method of the DX behavior
+  [gbastien]
+
+
+0.3 (2015-07-14)
+----------------
+
+- Corrected default value
+  [sgeulette]
+- Little optimization
+  [sgeulette]
+
+
+0.2 (2015-06-18)
+----------------
+
+- Added field `role_bypassing_talcondition` to define who can bypass the condition
+  [anuyens]
+- Added translations for new field
+  [gbastien]
+
+
+0.1 (2015-06-01)
+----------------
+
+- Initial release.
+  [IMIO]
+
+

collective.behavior.talcondition-1.0a2.dist-info/RECORD

@@ -0,0 +1,32 @@
+collective.behavior.talcondition-1.0a2-py3.11-nspkg.pth,sha256=8ssgqEuqS0ZiVuimfRty8lTM8d_9gCEdbC3ovq8TMBE,1077
+collective/behavior/talcondition/__init__.py,sha256=LcX1iez83P4ovdTlWnrAMFGE8tDnoYVhLbUc-LSCruA,308
+collective/behavior/talcondition/behavior.py,sha256=d4bvIeo21YD2sk5NGO-mJJQgYNHwyehHo9CQOJRjAnU,2824
+collective/behavior/talcondition/configure.zcml,sha256=RkFMsZNh5h9HrFwZ9wc6nWZG8LefVd3FJiEc1pX3RIc,2172
+collective/behavior/talcondition/extender.py,sha256=mVM0-nCgdyuAbwM7p0EBwo41lUdbqbKjtCF0hIGJX_s,2806
+collective/behavior/talcondition/interfaces.py,sha256=553o_qz9KihxgWwHQPayjbKmic-1brFRFJX3V02s58w,432
+collective/behavior/talcondition/setuphandlers.py,sha256=yOHG-PwzJ9w2XRmxz40QvBSd9lo84Rve7JCpKlxCe_E,256
+collective/behavior/talcondition/testing.py,sha256=9s_Nd5BOVCDN2tufG9T45n80DM3b6gqHokKdrSr3Vxo,2894
+collective/behavior/talcondition/testing.zcml,sha256=A8ITPtLBVw7dji7tX8-saImpAjj1Rz3f8De9TlNYeak,771
+collective/behavior/talcondition/utils.py,sha256=SzK5ZEgUFj6IhFLniw_yLpFTRQ8cHp49i-hRPU_tz50,5037
+collective/behavior/talcondition/locales/es/LC_MESSAGES/collective.behavior.talcondition.po,sha256=RZGb3WMN_9e9vEmQXx2VW7Y_6BLY-25uqjsMmZcZFE4,1644
+collective/behavior/talcondition/locales/fr/LC_MESSAGES/collective.behavior.talcondition.po,sha256=dhk-pCBMIbVyrXC1rCWV73t1meM3GHUlonLUpEbqIq4,1339
+collective/behavior/talcondition/profiles/default/browserlayer.xml,sha256=sKQd1RtLVWeUrOGsXGoDiyBNao4lPJf_-Z9eLQz3cas,196
+collective/behavior/talcondition/profiles/default/collectivebehaviortalcondition_marker.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+collective/behavior/talcondition/profiles/default/metadata.xml,sha256=grYUSMlCKb0kl1ivG9K842y6xncDXoJQcYJ96YhfvTU,67
+collective/behavior/talcondition/profiles/testing/metadata.xml,sha256=pcOw5lpsd7qgUxIDpPhMtaiviIU5jOLUn4wOXa-GabI,181
+collective/behavior/talcondition/profiles/testing/types.xml,sha256=Cxf94scAK_n0a29rLkRBO2TjCMDHCwDqOH1MYl95_BA,227
+collective/behavior/talcondition/profiles/testing/types/testtype.xml,sha256=vnK75Tr-j4hnz8zUxD0BNVJbLcmra60k7EbPwkWujBg,1916
+collective/behavior/talcondition/profiles/uninstall/browserlayer.xml,sha256=pi4OhQBeCcEUhbuz5z4EadAJE-SrA3ZIIvB4_dxl7ao,210
+collective/behavior/talcondition/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+collective/behavior/talcondition/tests/test_behavior.py,sha256=uXjHPp2NCC7ECBrgQnj_jfMb_ZdlUNxtY_CvcA8nIhc,2352
+collective/behavior/talcondition/tests/test_extender.py,sha256=goXwqPBMODNob_Qtif8svd1vJ0fBNEhQWvUJiPtkdiI,1321
+collective/behavior/talcondition/tests/test_robot.py,sha256=4bSKzSOaLMuirgdQ_kzZiMh02THRvzrAhik79h73h8k,633
+collective/behavior/talcondition/tests/test_setup.py,sha256=vvObzrvsPmLzSelqHWwEYDLifoFaSD-s4daSQvf5VUk,2483
+collective/behavior/talcondition/tests/test_utils.py,sha256=bsEy_BL2HqEtXdXiTBrZIGhSH03aBF4Sf4Oettukmt4,5289
+collective/behavior/talcondition/tests/robot/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+collective.behavior.talcondition-1.0a2.dist-info/METADATA,sha256=oSY1vaAac-SLWE3kAYJ_4eY6vVVvx6Zzu1Uu3mIwHZY,6612
+collective.behavior.talcondition-1.0a2.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+collective.behavior.talcondition-1.0a2.dist-info/entry_points.txt,sha256=b5cHz9FINNyhunUZ6BJOQMhgeAi2x9UcnAkA9l8KEC4,40
+collective.behavior.talcondition-1.0a2.dist-info/namespace_packages.txt,sha256=NmZRn6gW7dnyJ88Ktn-wkFv_xKxDhHkifpxxdnroaaA,31
+collective.behavior.talcondition-1.0a2.dist-info/top_level.txt,sha256=FyC0xnd95fkjCaKazR3nfIgNqhWMpB0mYBlzALyXKTg,11
+collective.behavior.talcondition-1.0a2.dist-info/RECORD,,

collective.behavior.talcondition-1.0a2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

collective.behavior.talcondition-1.0a2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[z3c.autoinclude.plugin]
+target = plone

collective.behavior.talcondition-1.0a2.dist-info/namespace_packages.txt

@@ -0,0 +1,2 @@
+collective
+collective.behavior

collective.behavior.talcondition-1.0a2.dist-info/top_level.txt

@@ -0,0 +1 @@
+collective