Metadata-Version: 1.0
Name: plone.behavior
Version: 1.0b2
Summary: Infrastructure for maintaining a registry of available behaviors
Home-page: http://plone.org
Author: Martin Aspeli
Author-email: optilude@gmail.com
License: LGPL
Description: ==============
        plone.behavior
        ==============
        
        By Martin Aspeli
        
        This package provides optional support for "behaviors". A behavior is
        essentially a conditionally available adapter.
        
        For example, let's say that your application needs to support object-level
        locking, and that this can be modelled via an adapter, but you want to leave
        it until runtime to determine whether locking is enabled for a particular
        object. You could then register locking as a behavior.
        
        Requirements
        ------------
        
        This package comes with support for registering behaviors and factories. It
        does not, however, implement the policy for determining what behaviors are
        enabled on a particular object at a particular time. That decision is deferred
        to an `IBehaviorAssignable` adapter, which you must implement.
        
        The intention is that behavior assignment is generic across an application,
        used for multiple, optional behaviors. It probably doesn't make much sense to
        use plone.behavior for a single type of behavior. The means to keep track
        of which behaviors are enabled for what types of objects will be application
        specific.
        
        Usage
        -----
        
        A behavior is written much like an adapter, except that you don't specify
        the type of context being adapted directly. For example::
        
        from zope.interface import Interface, implements
        
        class ILockingSupport(Interface):
        """Support locking
        """
        
        def lock():
        """Lock an object
        """
        
        def unlock():
        """Unlock an object
        """
        
        class LockingSupport(object):
        implements(ILockingSupport)
        
        def __init__(self, context):
        self.context = context
        
        def lock(self):
        # do something
        
        def unlock(self):
        # do something
        
        This interface (which describes the type of behavior) and class (which
        describes the implementation of the behavior) then need to be registered.
        
        The simplest way to do that is to load the meta.zcml file from this package
        and use ZCML::
        
        <configure
        xmlns="http://namespaces.zope.org/zope"
        xmlns:plone="http://namespaces.plone.org/plone"
        i18n_domain="my.package">
        
        <include package="plone.behavior" file="meta.zcml" />
        
        <plone:behavior
        name="my.package.Locking"
        title="Locking support"
        description="Optional object-level locking"
        interface=".interfaces.ILockingSupport"
        factory=".locking.LockingSupport"
        />
        
        </configure>
        
        After this is done - and presuming an appropriate IBehaviorAssignable adapter
        exists for the context - you can adapt a context to ILockingSupport as
        normal::
        
        locking = ILockingSupport(context, None)
        
        if locking is not None:
        locking.lock()
        
        You'll get an instance of LockingSupport if context can be adapted to
        IBehaviorAssignable (which, recall, is application specific), and if the
        implementation of IBehaviorAssignable says that this context supports this
        particular behavior.
        
        Please see behavior.txt and directives.txt for more details.
        
        =========
        Changelog
        =========
        
        1.0b1 - Released April 27th 2008
        --------------------------------
        
        * Initial release
        
Keywords: Plone behavior registry
Platform: UNKNOWN
Classifier: Framework :: Plone
Classifier: Programming Language :: Python
Classifier: Topic :: Software Development :: Libraries :: Python Modules
