[Testbot] Plone 5.0 - Python 2.7 - Build # 3091 - Still failing! - 0 failure(s)

jenkins at plone.org jenkins at plone.org
Sat Aug 23 05:30:31 UTC 2014


-------------------------------------------------------------------------------
Plone 5.0 - Python 2.7 - Build # 3091 - Still Failing!
-------------------------------------------------------------------------------

http://jenkins.plone.org/job/plone-5.0-python-2.7/3091/


-------------------------------------------------------------------------------
CHANGES
-------------------------------------------------------------------------------

Repository: plone.behavior
Branch: refs/heads/master
Date: 2014-08-23T01:14:15+02:00
Author: Gil Forcada (gforcada) <gforcada at gnome.org>
Commit: https://github.com/plone/plone.behavior/commit/69d564e59f01f3f4499b474600a881986ea7f543

Whitespaces cleanup

Files changed:
M README.txt
M docs/HISTORY.txt
M docs/INSTALL.txt
M plone/behavior/annotation.py
M plone/behavior/annotation.txt
M plone/behavior/behaviors.txt
M plone/behavior/directives.txt
M plone/behavior/factory.py
M plone/behavior/interfaces.py
M plone/behavior/markers.py
M plone/behavior/meta.zcml
M plone/behavior/metaconfigure.py
M plone/behavior/registration.py
M plone/behavior/tests.py

diff --git a/README.txt b/README.txt
index 798f31b..a250c95 100644
--- a/README.txt
+++ b/README.txt
@@ -2,7 +2,7 @@
 plone.behavior
 ==============
 
-This package provides optional support for "behaviors". A behavior is 
+This package provides optional support for "behaviors". A behavior is
 a re-usable aspect of an object that can be enabled or disabled without
 changing the component registry.
 
@@ -14,7 +14,7 @@ In some cases, the interface can be used as a marker interface as well.
 
 As an example, let's say that your application needs to support object-level
 locking, and that this can be modeled via an adapter, but you want to leave
-it until runtime to determine whether locking is enabled for a particular 
+it until runtime to determine whether locking is enabled for a particular
 object. You could then register locking as a behavior.
 
 Requirements
@@ -30,7 +30,7 @@ instances. To do that, you can either use an event handler to mark an object
 when it is created, or a dynamic __providedBy__ descriptor that does the
 lookup on the fly (but you probably want some caching).
 
-The intention is that behavior assignment is generic across an application, 
+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 object. The means to keep track
 of which behaviors are enabled for what types of objects will be application
@@ -47,31 +47,31 @@ the type of context being adapted directly. For example::
     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 
+
+The simplest way to do that is to load the meta.zcml file from this package
 and use ZCML::
 
     <configure
@@ -80,18 +80,18 @@ and use ZCML::
         i18n_domain="my.package">
 
         <include package="plone.behavior" file="meta.zcml" />
-        
+
         <plone:behavior
             title="Locking support"
             description="Optional object-level locking"
             provides=".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 
+exists for the context - you can adapt a context to ILockingSupport as
 normal::
 
     locking = ILockingSupport(context, None)
@@ -99,13 +99,13 @@ normal::
     if locking is not None:
         locking.lock()
 
-You'll get an instance of LockingSupport if context can be adapted to 
+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.
 
 It is also possible to let the provided interface act as a marker interface
-that is to be provided directly by the instance. To achieve this, omit the 
+that is to be provided directly by the instance. To achieve this, omit the
 'factory' argument. This is useful if you need to register other adapters
 (including views and viewlets) for instances providing a particular behavior.
 
diff --git a/docs/HISTORY.txt b/docs/HISTORY.txt
index 4dd1b86..c368d2e 100644
--- a/docs/HISTORY.txt
+++ b/docs/HISTORY.txt
@@ -44,7 +44,7 @@ Changelog
   apologies, but it's now or never. :-/
 
   If you find that you get import errors or unknown keyword arguments in your
-  code, please change names from foo_bar too fooBar, e.g. 
+  code, please change names from foo_bar too fooBar, e.g.
   enumerate_behaviors() becomes enumerateBehaviors().
   [optilude]
 
@@ -66,7 +66,7 @@ Changelog
 * Rename the 'subtype' attribute of <plone:behavior /> to 'marker' to
   be more explicit about its purpose. This is a backwards
   incompatible change!
-  [optilude]  
+  [optilude]
 
 1.0b3 - 2009-04-17
 ------------------
diff --git a/docs/INSTALL.txt b/docs/INSTALL.txt
index 82f3502..75da00c 100644
--- a/docs/INSTALL.txt
+++ b/docs/INSTALL.txt
@@ -4,7 +4,7 @@ plone.behavior Installation
 To install plone.behavior into the global Python environment (or a workingenv),
 using a traditional Zope 2 instance, you can do this:
 
- * When you're reading this you have probably already run 
+ * When you're reading this you have probably already run
    ``easy_install plone.behavior``. Find out how to install setuptools
    (and EasyInstall) here:
    http://peak.telecommunity.com/DevCenter/EasyInstall
@@ -20,24 +20,24 @@ Alternatively, if you are using zc.buildout and the plone.recipe.zope2instance
 recipe to manage your project, you can do this:
 
  * Add ``plone.behavior`` to the list of eggs to install, e.g.:
- 
+
     [buildout]
     ...
     eggs =
         ...
         plone.behavior
-        
+
   * Tell the plone.recipe.zope2instance recipe to install a ZCML slug:
-  
+
     [instance]
     recipe = plone.recipe.zope2instance
     ...
     zcml =
         plone.behavior
-        
+
   * Re-run buildout, e.g. with:
-  
+
     $ ./bin/buildout
-        
+
 You can skip the ZCML slug if you are going to explicitly include the package
 from another package's configure.zcml file.
diff --git a/plone/behavior/annotation.py b/plone/behavior/annotation.py
index 68e4189..0eeb106 100644
--- a/plone/behavior/annotation.py
+++ b/plone/behavior/annotation.py
@@ -8,15 +8,15 @@
 
 class AnnotationsFactoryImpl(object):
     """A factory that knows how to store data in annotations.
-    
+
     Each value will be stored as a primitive in the annotations under a key
     that consists of the full dotted name to the field being stored.
-    
+
     This class is not sufficient as an adapter factory on its own. It must
     be initialised with the schema interface in the first place. That is the
     role of the Annotations factory below.
     """
-    
+
     adapts(IAnnotatable)
 
     def __init__(self, context, schema):
@@ -24,18 +24,18 @@ def __init__(self, context, schema):
         self.__dict__['prefix'] = schema.__identifier__ + '.'
         self.__dict__['annotations'] = IAnnotations(context)
         alsoProvides(self, schema)
-    
+
     def __getattr__(self, name):
         if name not in self.__dict__['schema']:
             raise AttributeError(name)
-        
+
         annotations = self.__dict__['annotations']
         key_name = self.__dict__['prefix'] + name
         if key_name not in annotations:
             return self.__dict__['schema'][name].missing_value
-        
+
         return annotations[key_name]
-    
+
     def __setattr__(self, name, value):
         if name not in self.__dict__['schema']:
             super(AnnotationsFactoryImpl, self).__setattr__(name, value)
@@ -45,11 +45,11 @@ def __setattr__(self, name, value):
 class AnnotationStorage(object):
     """Behavior adapter factory class for storing data in annotations.
     """
-    
+
     def __init__(self, schema):
         self.schema = schema
         self.__component_adapts__ = (IAnnotatable,)
-    
+
     def __call__(self, context):
          return AnnotationsFactoryImpl(context, self.schema)
 
diff --git a/plone/behavior/annotation.txt b/plone/behavior/annotation.txt
index 734d660..26d3afd 100644
--- a/plone/behavior/annotation.txt
+++ b/plone/behavior/annotation.txt
@@ -16,17 +16,17 @@ Let's show how this may be registered in ZCML.
     ...      xmlns="http://namespaces.zope.org/zope"
     ...      xmlns:plone="http://namespaces.plone.org/plone"
     ...      i18n_domain="plone.behavior.tests">
-    ...     
+    ...
     ...     <include package="zope.component" file="meta.zcml" />
     ...     <include package="plone.behavior" file="meta.zcml" />
     ...     <include package="zope.annotation" />
-    ...     
+    ...
     ...     <plone:behavior
     ...         title="Annotation behavior"
     ...         provides="plone.behavior.tests.IAnnotationStored"
     ...         factory="plone.behavior.AnnotationStorage"
     ...         />
-    ...         
+    ...
     ... </configure>
     ... """
 
@@ -47,25 +47,25 @@ IBehaviorAssignable adapter. See behaviors.txt for more details.
     >>> class TestingBehaviorAssignable(object):
     ...     implements(IBehaviorAssignable)
     ...     adapts(Interface)
-    ...     
+    ...
     ...     def __init__(self, context):
     ...         self.context = context
-    ...     
+    ...
     ...     def supports(self, behavior_interface):
     ...         global BEHAVIORS
     ...         return behavior_interface in BEHAVIORS.get(self.context.__class__, [])
-    ...         
+    ...
     ...     def enumerateBehaviors(self):
     ...         global BEHAVIORS
     ...         for iface in BEHAVIORS.get(self.context.__class__, []):
     ...             yield getUtility(IBehavior, iface.__identifier__)
 
     >>> provideAdapter(TestingBehaviorAssignable)
-    
+
     >>> class Context(object):
     ...     implements(IAttributeAnnotatable)
     >>> BEHAVIORS[Context] = [IAnnotationStored]
-    
+
     >>> context = Context()
 
 We can now adapt the context to our new interface.
@@ -76,7 +76,7 @@ Before we've set anything, we get the field's missing_value
 
     >>> adapted.some_field is IAnnotationStored['some_field'].missing_value
     True
-    
+
 Let's look at the annotations also:
 
     >>> sorted(IAnnotations(context).items())
diff --git a/plone/behavior/behaviors.txt b/plone/behavior/behaviors.txt
index 7719ade..5c824eb 100644
--- a/plone/behavior/behaviors.txt
+++ b/plone/behavior/behaviors.txt
@@ -24,9 +24,9 @@ Then, for each behavior:
  * Register the behavior. This consists of a utility providing IBehavior and
    an adapter factory based on IBehaviorAdapterFactory. The <plone:behavior />
    ZCML directive makes this easy. See directives.txt.
-   
+
 An example might be::
-   
+
     <plone:behavior
         title="Locking"
         description="Support object-level locking"
@@ -40,7 +40,7 @@ to attempt to use it, e.g.::
     locking = ILocking(context, None)
     if locking is not None:
         locking.lock()
-      
+
 Here, ILocking is a registered behavior interface. The adaptation will only
 succeed if the context support behaviors (i.e. it can be adapted to
 IBehaviorAssignable), and if the ILocking behavior is currently enabled for
@@ -58,7 +58,7 @@ interface ILockingSupport:
     >>> class ILockingSupport(Interface):
     ...     def lock():
     ...         "Lock the context"
-    ...     
+    ...
     ...     def unlock():
     ...         "Unlock the context"
 
@@ -66,10 +66,10 @@ interface ILockingSupport:
     ...     implements(ILockingSupport)
     ...     def __init__(self, context):
     ...         self.context = context
-    ...         
+    ...
     ...     def lock(self):
     ...         print 'Locked', repr(self.context)
-    ...     
+    ...
     ...     def unlock(self):
     ...         print 'Unlocked', repr(self.context)
 
@@ -79,7 +79,7 @@ interface that makes this easy:
 
     >>> from plone.behavior.registration import BehaviorRegistration
     >>> registration = BehaviorRegistration(
-    ...     title=u"Locking support", 
+    ...     title=u"Locking support",
     ...     description=u"Provides content-level locking",
     ...     interface=ILockingSupport,
     ...     marker=None,
@@ -88,7 +88,7 @@ interface that makes this easy:
     >>> from zope.component import provideUtility
     >>> provideUtility(registration, name=ILockingSupport.__identifier__)
 
-NOTE: By convention, the behavior name should be the same as the identifier 
+NOTE: By convention, the behavior name should be the same as the identifier
 of its interface. This convention is maintained by the <plone:behavior />
 ZCML directive.
 
@@ -109,14 +109,14 @@ class.
     >>> from zope.component import provideAdapter
     >>> provideAdapter(factory=factory, adapts=(Interface,), provides=ILockingSupport)
 
-One this is registered, it will be possible to adapt any context to 
+One this is registered, it will be possible to adapt any context to
 ILockingSupport, if:
 
-  * The context can be adapted to IBehaviorAssignable. This is an 
+  * The context can be adapted to IBehaviorAssignable. This is an
     interface that is used to determine if a particular object supports
     a particular behavior.
-    
-  * The behavior is enabled, i.e. the IBehaviorAssignable implementation 
+
+  * The behavior is enabled, i.e. the IBehaviorAssignable implementation
     says it is.
 
 Right now, neither of those things are true, so we'll get a TypeError when
@@ -155,14 +155,14 @@ The adapter can thus be registered like this:
     >>> class TestingBehaviorAssignable(object):
     ...     implements(IBehaviorAssignable)
     ...     adapts(Interface)
-    ...     
+    ...
     ...     def __init__(self, context):
     ...         self.context = context
-    ...     
+    ...
     ...     def supports(self, behavior_interface):
     ...         global BEHAVIORS
     ...         return behavior_interface in BEHAVIORS.get(self.context.__class__, [])
-    ...         
+    ...
     ...     def enumerateBehaviors(self):
     ...         global BEHAVIORS
     ...         for iface in BEHAVIORS.get(self.context.__class__, []):
@@ -174,7 +174,7 @@ NOTE: Again, we are relying on the convention that the IBehavior utility
 name is the identifier of the behavior interface.
 
 At this point, we know that the context support behavior assignment (since
-there is an adapter for it), but it's not yet enabled, so we still can't 
+there is an adapter for it), but it's not yet enabled, so we still can't
 adapt.
 
     >>> behavior = ILockingSupport(context, None)
@@ -190,10 +190,10 @@ However, if we enable the behavior for this type...
     >>> behavior = ILockingSupport(context, None)
     >>> behavior is None
     False
-    
+
     >>> behavior.lock()
     Locked <sample context>
-    
+
 Marker interfaces
 -----------------
 
@@ -214,7 +214,7 @@ by this package. One of two possible configurations is possible:
     enabled behaviors can be added to behavior-aware classes.
   * An event handler can be installed that marks newly created instances with
     the markers of all enabled behaviors.
-    
+
 The first approach is better in many ways, because it can be made more robust
 in case a marker interface is removed or renamed, and because it is possible
 to turn off behavior markers without finding all objects providing the
@@ -249,7 +249,7 @@ as well.
     ...     implements(ITagging)
     ...     def __init__(self, context):
     ...         self.context = context
-    ...         
+    ...
     ...     def get_tags(self, value):
     ...         return getattr(self.context, '__tags__', [])
     ...     def set_tags(self, value):
@@ -282,12 +282,12 @@ interface should not be applied.
     False
     >>> ITaggable.providedBy(context1)
     False
-    
+
     >>> applyMarkers(context1, ObjectCreatedEvent(context1))
 
     >>> ITaggable.providedBy(context1)
     False
-    
+
 If we now turn on the behavior, the marker should be applied when the event
 is fired.
 
@@ -298,15 +298,15 @@ is fired.
     True
     >>> ITaggable.providedBy(context2)
     False
-    
+
     >>> applyMarkers(context2, ObjectCreatedEvent(context2))
 
     >>> ITaggable.providedBy(context2)
     True
-    
+
 Note that since this is applied per-instance, old instances do not get the
 marker interface automatically:
-    
+
     >>> ITaggable.providedBy(context1)
     False
 
diff --git a/plone/behavior/directives.txt b/plone/behavior/directives.txt
index df24f62..950dc37 100644
--- a/plone/behavior/directives.txt
+++ b/plone/behavior/directives.txt
@@ -11,32 +11,32 @@ plone.behavior.tests:
     for any context.
 
   * An adapter behavior with a factory and an explicit context restriction.
-  
+
   * An adapter behavior where a context restriction is implied by the
     adapts() declaration on the factory.
-    
+
   * A behavior with a marker marker interface.
-  
+
   * A behavior using the standard annotation factory
-  
+
   * A behavior providing a marker interface and using an adapter factory.
-  
+
     >>> configuration = """\
     ... <configure
     ...      package="plone.behavior"
     ...      xmlns="http://namespaces.zope.org/zope"
     ...      xmlns:plone="http://namespaces.plone.org/plone"
     ...      i18n_domain="plone.behavior.tests">
-    ...     
+    ...
     ...     <include package="plone.behavior" file="meta.zcml" />
-    ...     
+    ...
     ...     <plone:behavior
     ...         title="Adapter behavior"
     ...         description="A basic adapter behavior"
     ...         provides=".tests.IAdapterBehavior"
     ...         factory=".tests.AdapterBehavior"
     ...         />
-    ...     
+    ...
     ...     <plone:behavior
     ...         title="Context restricted behavior"
     ...         provides=".tests.IRestrictedAdapterBehavior"
@@ -49,18 +49,18 @@ plone.behavior.tests:
     ...         provides=".tests.IImpliedRestrictionAdapterBehavior"
     ...         factory=".tests.ImpliedRestrictionAdapterBehavior"
     ...         />
-    ...     
+    ...
     ...     <plone:behavior
     ...         title="Marker interface behavior"
     ...         provides=".tests.IMarkerBehavior"
     ...         />
-    ...         
+    ...
     ...     <plone:behavior
     ...         title="Annotation storage behavior"
     ...         provides=".tests.IAnnotationStored"
     ...         factory="plone.behavior.AnnotationStorage"
     ...         />
-    ...         
+    ...
     ...     <plone:behavior
     ...         title="Marker and adapter"
     ...         provides=".tests.IMarkerAndAdapterBehavior"
@@ -79,7 +79,7 @@ Let's first verify that we don't have the dummy data registered already:
     >>> from plone.behavior.interfaces import IBehavior
     >>> [u for u in sm.registeredUtilities() if u.name == u"plone.behavior.tests.IAdapterBehavior"]
     []
-    
+
     >>> from plone.behavior.tests import IAdapterBehavior
     >>> [a for a in sm.registeredAdapters() if a.provided == IAdapterBehavior]
     []
@@ -97,7 +97,7 @@ With this in place, the behaviors should be registered, e.g:
     >>> sorted([u for u in sm.registeredUtilities() if u.name == u"plone.behavior.tests.IAdapterBehavior"]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
     [UtilityRegistration(..., IBehavior, 'plone.behavior.tests.IAdapterBehavior', <BehaviorRegistration for plone.behavior.tests.IAdapterBehavior>,...),
      UtilityRegistration(..., IInterface, 'plone.behavior.tests.IAdapterBehavior', IAdapterBehavior,...)]
-    
+
     >>> from plone.behavior.tests import IAdapterBehavior
     >>> [a for a in sm.registeredAdapters() if a.provided == IAdapterBehavior]  # doctest: +ELLIPSIS
     [AdapterRegistration(..., [Interface], IAdapterBehavior, '', <plone.behavior.factory.BehaviorAdapterFactory object at ...>, ...)]
@@ -109,45 +109,45 @@ Let us test the various utilities and the underlying adapters more carefully.
 
 1) A standard behavior with an interface and a factory. It will be registered
 for any context.
-    
+
     >>> dummy = getUtility(IBehavior, name=u"plone.behavior.tests.IAdapterBehavior")
     >>> dummy.title
     u'Adapter behavior'
-    
+
     >>> dummy.description
     u'A basic adapter behavior'
 
     >>> dummy.interface
     <InterfaceClass plone.behavior.tests.IAdapterBehavior>
-    
+
     >>> dummy.marker is None
     True
-    
+
     >>> dummy.factory
     <class 'plone.behavior.tests.AdapterBehavior'>
-    
+
     >>> from plone.behavior.tests import IAdapterBehavior
     >>> [a.required for a in sm.registeredAdapters() if a.provided == IAdapterBehavior][0]
     (<InterfaceClass zope.interface.Interface>,)
-    
+
 2) An adapter behavior with a factory and an explicit context restriction.
 
     >>> dummy = getUtility(IBehavior, name=u"plone.behavior.tests.IRestrictedAdapterBehavior")
     >>> dummy.title
     u'Context restricted behavior'
-    
+
     >>> dummy.description is None
     True
-    
+
     >>> dummy.interface
     <InterfaceClass plone.behavior.tests.IRestrictedAdapterBehavior>
-    
+
     >>> dummy.marker is None
     True
-    
+
     >>> dummy.factory
     <class 'plone.behavior.tests.RestrictedAdapterBehavior'>
-    
+
     >>> from plone.behavior.tests import IRestrictedAdapterBehavior
     >>> [a.required for a in sm.registeredAdapters() if a.provided == IRestrictedAdapterBehavior][0]
     (<InterfaceClass plone.behavior.tests.IMinimalContextRequirements>,)
@@ -158,63 +158,63 @@ declaration on the factory.
     >>> dummy = getUtility(IBehavior, name=u"plone.behavior.tests.IImpliedRestrictionAdapterBehavior")
     >>> dummy.title
     u'Factory-implied context restricted behavior'
-    
+
     >>> dummy.description is None
     True
 
     >>> dummy.interface
     <InterfaceClass plone.behavior.tests.IImpliedRestrictionAdapterBehavior>
-    
+
     >>> dummy.marker is None
     True
-    
+
     >>> dummy.factory
     <class 'plone.behavior.tests.ImpliedRestrictionAdapterBehavior'>
-    
+
     >>> from plone.behavior.tests import IImpliedRestrictionAdapterBehavior
     >>> [a.required for a in sm.registeredAdapters() if a.provided == IImpliedRestrictionAdapterBehavior][0]
     (<InterfaceClass plone.behavior.tests.ISomeContext>,)
-    
+
 4) A behavior with a marker marker interface.
 
     >>> dummy = getUtility(IBehavior, name=u"plone.behavior.tests.IMarkerBehavior")
     >>> dummy.title
     u'Marker interface behavior'
-    
+
     >>> dummy.description is None
     True
 
     >>> dummy.interface
     <InterfaceClass plone.behavior.tests.IMarkerBehavior>
-    
+
     >>> dummy.marker
     <InterfaceClass plone.behavior.tests.IMarkerBehavior>
-    
+
     >>> dummy.factory is None
     True
-    
+
     >>> from plone.behavior.tests import IMarkerBehavior
     >>> [a.required for a in sm.registeredAdapters() if a.provided == IMarkerBehavior]
     []
-  
+
 5) A behavior using the standard annotation factory
 
     >>> dummy = getUtility(IBehavior, name=u"plone.behavior.tests.IAnnotationStored")
     >>> dummy.title
     u'Annotation storage behavior'
-    
+
     >>> dummy.description is None
     True
 
     >>> dummy.interface
     <InterfaceClass plone.behavior.tests.IAnnotationStored>
-    
+
     >>> dummy.marker is None
     True
-    
+
     >>> dummy.factory # doctest: +ELLIPSIS
     <plone.behavior.annotation.AnnotationStorage object at ...>
-    
+
     >>> from plone.behavior.tests import IAnnotationStored
     >>> [a.required for a in sm.registeredAdapters() if a.provided == IAnnotationStored][0]
     (<InterfaceClass zope.annotation.interfaces.IAnnotatable>,)
@@ -224,19 +224,19 @@ declaration on the factory.
     >>> dummy = getUtility(IBehavior, name=u"plone.behavior.tests.IMarkerAndAdapterBehavior")
     >>> dummy.title
     u'Marker and adapter'
-    
+
     >>> dummy.description is None
     True
 
     >>> dummy.interface
     <InterfaceClass plone.behavior.tests.IMarkerAndAdapterBehavior>
-    
+
     >>> dummy.marker
     <InterfaceClass plone.behavior.tests.IMarkerAndAdapterMarker>
-    
+
     >>> dummy.factory # doctest: +ELLIPSIS
     <plone.behavior.annotation.AnnotationStorage object at ...>
-    
+
     >>> from plone.behavior.tests import IMarkerAndAdapterBehavior
     >>> [a.required for a in sm.registeredAdapters() if a.provided == IMarkerAndAdapterBehavior][0]
     (<InterfaceClass zope.annotation.interfaces.IAnnotatable>,)
diff --git a/plone/behavior/factory.py b/plone/behavior/factory.py
index 931e53f..0b1a07c 100644
--- a/plone/behavior/factory.py
+++ b/plone/behavior/factory.py
@@ -5,10 +5,10 @@
 
 class BehaviorAdapterFactory(object):
     implements(IBehaviorAdapterFactory)
-    
+
     def __init__(self, behavior):
         self.behavior = behavior
-        
+
     def __call__(self, context):
         assignable = IBehaviorAssignable(context, None)
         if assignable is None:
diff --git a/plone/behavior/interfaces.py b/plone/behavior/interfaces.py
index dbe4a76..c860348 100644
--- a/plone/behavior/interfaces.py
+++ b/plone/behavior/interfaces.py
@@ -6,29 +6,29 @@
 class IBehaviorAssignable(Interface):
     """An object will be adapted to this interface to determine if it supports
     one or more behaviors.
-    
-    There is no default implementation of this adapter. The mechanism for 
+
+    There is no default implementation of this adapter. The mechanism for
     assigning behaiors to an object or type of object is application specific.
     """
-    
+
     def supports(behavior_interface):
         """Determine if the context supports the given behavior, returning
         True or False.
         """
-        
+
     def enumerateBehaviors():
         """Return an iterable of all the IBehaviors supported by the context.
         """
 
 class IBehavior(Interface):
-    """A description of a behavior. These should be registered as named 
+    """A description of a behavior. These should be registered as named
     utilities. There should also be an adapter factory registered, probably
     using IBehaviorAdapterFactory.
     """
 
     title = schema.TextLine(title=u"Short title of the behavior",
                             required=True)
-    
+
     description = schema.Text(title=u"Longer description of the behavior",
                               required=False)
 
@@ -53,22 +53,22 @@ class IBehaviorAdapterFactory(Interface):
     registering an adapter from Interface (or some other general source) to
     the behavior's interface that uses this factory, we can easily support
     the following semantics:
-    
+
         context = SomeObject()
         behavior_adapter = ISomeBehavior(context, None)
-     
-     The ISomeBehavior adapter factory (i.e. the object providing 
+
+     The ISomeBehavior adapter factory (i.e. the object providing
      IBehaviorAdapterFactory) will return None if
      IBehaviorAssignable(context).supports(ISomeBehavior) is False, or if
      the context cannot be adapted to IBehaviorAssignable at all.
     """
-    
+
     behavior = schema.Object(title=u"The behavior this is a factory for",
                              schema=IBehavior)
-    
+
     def __call__(context):
         """Invoke the behavior-specific factory if the context can be adapted
-        to IBehaviorAssignable and 
+        to IBehaviorAssignable and
         IBehaviorAssignable(context).supports(self.behavior.interface) returns
         True.
         """
@@ -78,6 +78,6 @@ class ISchemaAwareFactory(Interface):
     schema. The factory must be a callable that takes the schema as an
     argument and returns another callable that can create appropriate behavior
     factories on demand.
-    
+
     See annotation.py for an example.
     """
diff --git a/plone/behavior/markers.py b/plone/behavior/markers.py
index 99c5d4c..314ae10 100644
--- a/plone/behavior/markers.py
+++ b/plone/behavior/markers.py
@@ -5,11 +5,11 @@ def applyMarkers(obj, event):
     """Event handler to apply markers for all behaviors enabled
     for the given type.
     """
-    
+
     assignable = IBehaviorAssignable(obj, None)
     if assignable is None:
         return
-        
+
     for behavior in assignable.enumerateBehaviors():
         if behavior.marker is not None:
             alsoProvides(obj, behavior.marker)
diff --git a/plone/behavior/meta.zcml b/plone/behavior/meta.zcml
index 5805e02..d24311f 100644
--- a/plone/behavior/meta.zcml
+++ b/plone/behavior/meta.zcml
@@ -3,13 +3,13 @@
     i18n_domain="plone.behavior">
 
     <directives namespace="http://namespaces.plone.org/plone">
-        
+
         <directive
             name="behavior"
             schema=".metaconfigure.IBehaviorDirective"
             handler=".metaconfigure.behaviorDirective"
             />
-            
+
     </directives>
 
 </configure>
diff --git a/plone/behavior/metaconfigure.py b/plone/behavior/metaconfigure.py
index 7f2fb0b..08a78b0 100644
--- a/plone/behavior/metaconfigure.py
+++ b/plone/behavior/metaconfigure.py
@@ -18,27 +18,27 @@ class IBehaviorDirective(Interface):
     utility) and associated behavior adapter factory (a global, unnamed
     adapter)
     """
-    
+
     title = configuration_fields.MessageID(
         title=u"Title",
         description=u"A user friendly title for this behavior",
         required=True)
-        
+
     description = configuration_fields.MessageID(
         title=u"Description",
         description=u"A longer description for this behavior",
         required=False)
-                           
+
     provides = configuration_fields.GlobalInterface(
         title=u"An interface to which the behavior can be adapted",
         description=u"This is what the conditional adapter factory will be registered as providing",
         required=True)
-    
+
     marker = configuration_fields.GlobalInterface(
         title=u"A marker interface to be applied by the behavior",
         description=u"If provides is given and factory is not given, then this is optional",
         required=False)
-        
+
     factory = configuration_fields.GlobalObject(
         title=u"The factory for this behavior",
         description=u"If this is not given, the behavior is assumed to provide a marker interface",
@@ -48,9 +48,9 @@ class IBehaviorDirective(Interface):
         title=u"The type of object to register the conditional adapter factory for",
         description=u"This is optional - the default is to register the factory for zope.interface.Interface",
         required=False)
-        
+
 def behaviorDirective(_context, title, provides, description=None, marker=None, factory=None, for_=None):
-    
+
     if marker is None and factory is None:
         marker = provides
 
@@ -61,7 +61,7 @@ def behaviorDirective(_context, title, provides, description=None, marker=None,
     # this here so that the for_ interface may take this into account.
     if factory is not None and ISchemaAwareFactory.providedBy(factory):
         factory = factory(provides)
-    
+
     # Attempt to guess the factory's adapted interface and use it as the for_
     if for_ is None and factory is not None:
         adapts = getattr(factory, '__component_adapts__', None)
@@ -73,7 +73,7 @@ def behaviorDirective(_context, title, provides, description=None, marker=None,
             for_ = Interface
     elif for_ is None:
         for_ = Interface
-    
+
     registration = BehaviorRegistration(title=title,
                                         description=description,
                                         interface=provides,
@@ -81,14 +81,14 @@ def behaviorDirective(_context, title, provides, description=None, marker=None,
                                         factory=factory)
 
     adapter_factory = BehaviorAdapterFactory(registration)
-    
-    utility(_context, 
+
+    utility(_context,
             provides=IBehavior,
             name=provides.__identifier__,
             component=registration)
-    
+
     if factory is not None:
-        adapter(_context, 
+        adapter(_context,
                 factory=(adapter_factory,),
                 provides=provides,
                 for_=(for_,))
diff --git a/plone/behavior/registration.py b/plone/behavior/registration.py
index 05519b7..4084e0c 100644
--- a/plone/behavior/registration.py
+++ b/plone/behavior/registration.py
@@ -4,13 +4,13 @@
 
 class BehaviorRegistration(object):
     implements(IBehavior)
-    
+
     def __init__(self, title, description, interface, marker, factory):
         self.title = title
         self.description = description
         self.interface = interface
         self.marker = marker
         self.factory = factory
-        
+
     def __repr__(self):
         return "<BehaviorRegistration for %s>" % (self.interface.__identifier__,)
\ No newline at end of file
diff --git a/plone/behavior/tests.py b/plone/behavior/tests.py
index 68d6f79..4208596 100644
--- a/plone/behavior/tests.py
+++ b/plone/behavior/tests.py
@@ -30,7 +30,7 @@ def __init__(self, context):
 
 class IMinimalContextRequirements(Interface):
     pass
-    
+
 # Behavior with interface and for_ implied by factory
 
 class IImpliedRestrictionAdapterBehavior(Interface):
@@ -42,7 +42,7 @@ class ISomeContext(Interface):
 class ImpliedRestrictionAdapterBehavior(object):
     implements(IImpliedRestrictionAdapterBehavior)
     adapts(ISomeContext)
-    
+
     def __init__(self, context):
         self.context = context
 
@@ -66,7 +66,7 @@ class IMarkerAndAdapterMarker(Interface):
 
 def test_suite():
     return unittest.TestSuite((
-        
+
         doctest.DocFileSuite('behaviors.txt',
             # setUp=setUp,
             tearDown=zope.component.testing.tearDown),




-------------------------------------------------------------------------------
-------------- next part --------------
A non-text attachment was scrubbed...
Name: CHANGES.log
Type: application/octet-stream
Size: 34114 bytes
Desc: not available
URL: <http://lists.plone.org/pipermail/plone-testbot/attachments/20140823/0f75f2e1/attachment-0002.obj>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: build.log
Type: application/octet-stream
Size: 118994 bytes
Desc: not available
URL: <http://lists.plone.org/pipermail/plone-testbot/attachments/20140823/0f75f2e1/attachment-0003.obj>


More information about the Testbot mailing list