PlugIns/version.txt 0100644 0001752 0000627 00000000046 07543611370 014257 0 ustar roche upfront PlugIns-0-4-3p1-transactionagents-005
PlugIns/addFactory.dtml 0100644 0001752 0000627 00000005066 07543611370 015002 0 ustar roche upfront
Add an Object Factory
Add a Plug-In Factory
A Plug-In Factory allows you to place entries in Plug-in Containers'
add lists.
In the form below the Add list name is the name under which
your entry will appear in the appropriate add list, and the Plug-in
Kind is the name of the interface your plug-in supports. Your
plug-in will only appear on tabs which support plug-ins of that kind.
The Methods are the methods that will be invoked when a
user adds a new object. The "Form" method is used to display an "add"
form for the Plug-In, and the "Constructor" method is used to actually
create the Plug-In. Both methods must be objects in this
product, typically DTML Documents.
Before you can define a factory, you have to define one or more "methods",
such as Document or other objects that do the factory's work.
PlugIns/__init__.py 0100644 0001752 0000627 00000000624 07543611370 014144 0 ustar roche upfront from ImageFile import ImageFile
from PlugIns import \
PlugIn, PlugInBase, PlugInContainer, MakePICBase, genericAddForm, \
simpleConstructor, defaultConstructors, PlugInGroup, PlugInFinder, \
unifiedZClassRegistry, unifiedPlugInRegistry
def initialize(context):
context.registerHelp()
misc_ = {
"PlugInFactory_icon": ImageFile("www/PlugInFactory.gif", globals()),
}
del ImageFile
PlugIns/PlugIns.py 0100644 0001752 0000627 00000063222 07543611370 013771 0 ustar roche upfront from Globals import DTMLFile, default__class_init__, Persistent
from OFS.Folder import Folder; from OFS.PropertySheets import PropertySheets
from OFS.ObjectManager import ObjectManager; from OFS.SimpleItem import Item
from AccessControl.PermissionRole import PermissionRole
from App.ProductContext import ProductContext
import Acquisition, operator, string, Products; from Acquisition import aq_base
"""What are PlugIns, and what does this pattern do?
PROBLEM -- You are creating an object which you want to be end-user
configurable and extensible. You need to manage one or more sets of
user-selected collaborator objects which extend your base object. These
collaborator objects may be of multiple types, although within a given set,
they must all support the same collaboration interface. You don't know in
advance what types these objects will be, since you want users to be able
to create arbitrary implementations of your collaboration interface. You
also want to store, add, and manage these collaborators like regular Zope
sub-objects (so that acquistion, etc. still work), but don't want the
collaborators to show up on the Folder add list. Finally, for clarity,
you'd like each set of collaborators to have their own management tab
(ala Contents), but not show up on your Contents tab (if you have one).
SOLUTION -- PlugInContainers are Folder-derived objects which can have
specialized collaborators, namely PlugIns. PlugInContainers have management
tabs (implemented by PlugInGroups) for each collaboration interface
(__plugin_kind__). PlugIn classes are registered by kind, and
PlugInContainer classes have PlugInGroups which determine what kind(s)
of PlugIns can be added on each management tab.
EXAMPLE APPLICATIONS -- LoginManager has PlugInGroups for LoginMethods and
UserSources. If ZCatalog used a PlugInGroup for Indexes using a plugin
kind of "ZCatalog Index", users could create arbitrary kinds of index
objects without touching ZCatalog itself. And so on.
LIMITATIONS -- Due to the way PlugIn classes register their permissions
and constructors, they must be implemented directly in Python. It is
theoretically possible to create specialized constructors that would do
the same magic for ZClasses, but it would appear to require Fulton-like
Zen to do so. As Jim would say, "waaaa!"
"""
class PlugInBase:
"""
PlugIns are objects which collaborate with their container in some way. They
notify their container when they are added or removed. PlugIns have a 'kind'
(__plugin_kind__) which is a string that identifies their collaboration role.
"""
__plugin_kind__ = ""
def isAPlugIn(self):
return self.__plugin_kind__
def __init__(self,id='',title=''):
self.id = id
self.title = title
def _setup(self):
pass # easy subclass extension stub
def manage_afterAdd(self, item, container):
self._setup()
container = self.aq_parent
if self.__plugin_kind__ and hasattr(container,'_addPlugIn'):
container._addPlugIn(self)
def manage_beforeDelete(self, item, container):
container = self.aq_parent
if self.__plugin_kind__ and hasattr(container,'_removePlugIn'):
container._removePlugIn(self)
class PlugIn(PlugInBase, Item, Acquisition.Implicit, Persistent):
"""PlugIn that is compatible w/Zope management framework"""
pass
class PlugInContainer(PlugInBase, Folder):
"""
PlugInContainers are Folders which can have specialized collaborators known as
PlugIns, managed under management tabs provided by PlugInGroups.
This base class is useless in and of itself, as you must subclass it
to create a particular kind of PlugInContainer. Your subclass must
define attributes for each PlugInGroup you want to have, plus a
__plugin_groups__ attribute which contains all of the PlugInGroups. Example:
class MyPIC(PlugInContainer):
UserSources = PlugInGroup('UserSources',
['User Source'],attr='userSourcesList'
)
LoginMethods = PlugInGroup('LoginMethods',
['Login Method'], attr='loginMethodsList'
)
__plugin_groups__ = (UserSources, LoginMethods)
...
"""
manage_main = DTMLFile('www/main', globals())
def _addPlugIn(self, plugin):
"""Register a plugin with its group"""
plugin = getattr(plugin, 'aq_base', plugin)
kind = plugin.__plugin_kind__
for group in self.__plugin_groups__:
if kind in group.kinds:
group._addPlugIn(self, plugin)
break
else:
raise TypeError,("Unsupported plugin kind '%s'" % plugin.__plugin_kind__)
self.manage_refreshPlugIns()
def _removePlugIn(self, plugin):
"""Unregister plugin from any supporting group(s)"""
plugin = getattr(plugin, 'aq_base', plugin)
kind = plugin.__plugin_kind__
for group in self.__plugin_groups__:
if kind in group.kinds:
group._removePlugIn(self, plugin)
self.manage_refreshPlugIns()
def _findGroupFor(self, plugin):
"""Return the group a plugin belongs to"""
for group in self.__plugin_groups__:
group = group.__of__(self)
if plugin in group._objectValues():
return group
def _installPlugIn(self, plugin, message="", REQUEST=None):
"""Install a plugin (called by plugin constructors)"""
self._setObject(plugin.id, plugin)
if REQUEST is not None:
group = self._findGroupFor(plugin)
return group.manage_main(group, REQUEST, update_menu=1,
manage_tabs_message=message, URL='%s/%s/manage_workspace' % (REQUEST.URL1,group.id))
def manage_refreshPlugIns(self, REQUEST=None):
"""Update plugin registries"""
for group in self.__plugin_groups__:
group.__of__(self).manage_refreshPlugIns()
if REQUEST is not None:
return self.manage_main(self, REQUEST,
manage_tabs_message="PlugIns refreshed.")
manage_options_left = {'label':'Methods', 'action':'manage_main'},
manage_options_right = tuple(Folder.manage_options[1:])
def manage_options(self):
"""Construct manage_options (tabs) from left+plugin groups+right"""
def as_option(group):
d = {'label':group.title, 'action': group.id+'/manage_workspace'}
if hasattr(group,'help_info'): d['help']=group.help_info
return d
return self.manage_options_left + \
tuple(map(as_option,self.__plugin_groups__))+ \
self.manage_options_right
def all_meta_types(self,exclude_plugins=0):
mt = Folder.all_meta_types.im_func(self)
if not exclude_plugins:
mt=list(mt)
for g in self.__plugin_groups__:
mt.extend(g.__of__(self).all_meta_types())
return mt
def filtered_meta_types(self,user=None,exclude_plugins=0):
# rcc: filtered_meta_types complains about user as an argument
# mt = Folder.filtered_meta_types.im_func(self,user)
mt = Folder.filtered_meta_types.im_func(self)
if exclude_plugins:
return filter(lambda x: not x.has_key('plugin_add_method'), mt)
return mt
def manage_beforeDelete(self,item,container):
PlugInBase.manage_beforeDelete.im_func(self,item,container)
Folder.manage_beforeDelete(self,item,container)
def manage_afterAdd(self,item,container):
Folder.manage_afterAdd(self,item,container)
PlugInBase.manage_afterAdd.im_func(self,item,container)
__ac_permissions__ = (
('View management screens', ('manage_main','manage_refreshPlugIns')
),
)
default__class_init__(PlugInContainer)
PluggableContainer = PlugInContainer # Backward compatibility
def genericAddForm(pluginClass, globalDict=None):
"""Return a customized DTMLFile of the generic plugin Add form"""
className = pluginClass.__name__
formName = 'manage_add%sForm' % className
f = DTMLFile(
'genericAddForm', globals(),
title_ = pluginClass.meta_type,
constructor_ = ('manage_add%s' % className),
__name__ = formName
)
if globalDict is not None: globalDict[formName] = f
return f
_defaultConstructor = '''
def manage_add%(name)s(self, id, title='', REQUEST=None):
"""Add %(meta_type)s"""
ob = %(name)s(id, title)
return self.Destination()._installPlugIn(ob, "%(meta_type)s added", REQUEST)
'''
def simpleConstructor(pluginClass,globalDict):
name=pluginClass.__name__; meta_type = pluginClass.meta_type
exec _defaultConstructor % locals() in globalDict
return globalDict['manage_add%s' % name]
def defaultConstructors(pluginClass,globalDict):
return (
genericAddForm(pluginClass,globalDict),
simpleConstructor(pluginClass,globalDict)
)
class PlugInGroup(Acquisition.Implicit):
"""
PlugInGroups manage PlugIns of specific Kind(s) on behalf of a PlugInContainer.
The PlugIns are actually stored in the PlugInContainer, but the PlugInGroup
helps manage them as a group.
"""
def __init__(self, id, kinds, attr, title='', help=()):
"""
Create a PlugIn group to manage a registry of PlugIns of the specified kinds.
Registry will be stored in the PlugInContainer attribute specified by attr.
If attr is not specified, registry will be stored in the PlugInContainer's
__plugins__ attribute as a dictionary mapping kinds to lists of plugins.
"""
self.id,self.kinds,self.attr,self.title = id,tuple(kinds),attr,title
if help: self.help_info=help
def all_meta_types(self):
"""Return meta_types which can be added to this group"""
return unifiedPlugInRegistry(self, self.kinds)
# We need filtered meta types, but we don't want to be an ObjectManager
filtered_meta_types = ObjectManager.filtered_meta_types.im_func # Hack!
def _PlugInsChanged(self, container, pluginslist):
"""This is just a hookpoint for subclasses"""
pass
def manage_refreshPlugIns(self, REQUEST=None):
"""Refresh plugin registry"""
container = self.aq_inner.aq_parent
self._PlugInsChanged(container, getattr(container, self.attr, []))
if REQUEST is not None:
return self.manage_main(self, REQUEST,
manage_tabs_message="PlugIns refreshed.",
URL=REQUEST.URL1+'/manage_workspace')
def _objectValues(self):
container = self.aq_inner.aq_parent
return getattr(container, self.attr, [])
def objectValues(self):
"""Get objects contained within the group"""
container = self.aq_inner.aq_parent
return map (lambda x,c=container: x.__of__(c), self._objectValues())
def objectItems(self):
"""get (id, object) tuples of items in the group"""
return map(lambda x: (x.id, x), self.objectValues())
manage_main = manage_workspace = \
DTMLFile('www/PlugInGroup', globals())
manage_main._setName('manage_main')
manage_above = manage_below = ''
def _addPlugIn(self, container, plugin):
"""Register plug-in with group"""
l = getattr(container, self.attr, None) or []
if plugin not in l: l.append(plugin)
setattr(container, self.attr, l)
def _removePlugIn(self, container, plugin):
"""Unregister plug-in from group"""
l = getattr(container, self.attr, None) or []
l = filter(lambda x,p=plugin: x is not p, l)
setattr(container, self.attr, l)
def tabs_path_info(self, script, path):
path = self.absolute_url(relative=1) + '/foo'
return self.aq_inner.aq_parent.tabs_path_info(script, path)
def manage_first(self, ids=[], REQUEST=None):
"""Re-sort plugins, moving selected ones first"""
container = self.aq_inner.aq_parent
l = getattr(container, self.attr, None) or []
l = filter(lambda x,ids=ids: x.id in ids, l) + \
filter(lambda x,ids=ids: x.id not in ids, l)
setattr(container, self.attr, l)
container.manage_refreshPlugIns()
if REQUEST:
return self.manage_main(self,REQUEST,update_menu=1,
URL=REQUEST.URL1+'/manage_workspace')
def manage_cutObjects(self, ids, REQUEST=None):
"""Put a reference to the objects named in ids in the clip board"""
cp = self.aq_inner.aq_parent.manage_cutObjects(ids,REQUEST)
if REQUEST is not None:
return self.manage_main(self, REQUEST, cb_dataValid=1,
URL=REQUEST.URL1+'/manage_workspace')
return cp
def manage_copyObjects(self, ids, REQUEST=None, RESPONSE=None):
"""Put a reference to the objects named in ids in the clip board"""
cp = self.aq_inner.aq_parent.manage_copyObjects(ids,REQUEST)
if REQUEST is not None:
return self.manage_main(self, REQUEST, cb_dataValid=1,
URL=REQUEST.URL1+'/manage_workspace')
return cp
def manage_renameObject(self, id, new_id, REQUEST=None):
"""Rename a particular sub-object"""
self.aq_inner.aq_parent.manage_renameObject(id,new_id)
if REQUEST is not None:
return self.manage_main(self, REQUEST, update_menu=1,
URL=REQUEST.URL1+'/manage_workspace')
def manage_renameObjects(self, ids, new_ids, REQUEST=None):
"""Rename several sub-objects"""
self.aq_inner.aq_parent.manage_renameObjects(ids,new_ids)
if REQUEST is not None:
return self.manage_main(self, REQUEST, update_menu=1,
URL=REQUEST.URL1+'/manage_workspace')
def manage_delObjects(self, ids=[], REQUEST=None):
"""Delete subordinate objects"""
self.aq_inner.aq_parent.manage_delObjects(ids,REQUEST)
if REQUEST is not None:
return self.manage_main(self, REQUEST, update_menu=1,
URL=REQUEST.URL1+'/manage_workspace')
def _constructPlugIn(self,name,*args,**kwargs):
"""Create a plug-in - used when container wants defaults plugins"""
# Use filtered meta types so users can't bypass create permissions
for meta in self.filtered_meta_types(self.REQUEST.AUTHENTICATED_USER):
if meta['name']==name:
method = meta['plugin_add_method']
product = self.aq_inner.aq_parent.manage_addProduct[meta['product']]
method = getattr(product, method) # XXX 2.1.x compat
if not hasattr(method,'im_self'): args = (product,)+args
return apply(method, args, kwargs)
# XXX should have different permission for manage_first, but what?
__ac_permissions__ = (
('View management screens',
('manage_first','manage_main',
'manage_above', 'manage_below', 'manage_refreshPlugIns')
),
)
default__class_init__(PlugInGroup)
def PlugInFinder(PIG):
return lambda self,PIG=PIG: PIG.__of__(self).filtered_meta_types()
def MakePICBase(PIC):
import sys
d = sys.modules[PIC.__module__].__dict__
c = """
from Products.PlugIns.PlugIns import ZClass_for_PlugInContainer
class %(id)s_ZClassBase(%(id)s):
__name__ = "%(id)s"
manage_options = %(id)s.manage_options.im_func(%(id)s)
class ZClass_for_%(id)s(ZClass_for_PlugInContainer):
_zclass_ = %(id)s_ZClassBase
""" % {'id':PIC.__name__}
exec c in d
# Global PlugIn class registry
# key: kind name; value: lists of meta-type dicts for classes of kind
PlugInKinds = {}
class _ProductContextPatch:
def registerPlugInClass(self, instance_class=None, meta_type='',
permission=None, constructors=(),
icon=None, permissions=None, legacy=(),):
"""
Register a plug-in class. The class registered will not be included in the
master Products.meta_types registry, but only in the PlugInKinds registry.
To register a plug-in class, create an initialize() method in your product's
__init__.py. In it, call context.registerPlugInClass() with the parameters
you would use for a context.registerClass() call.
"""
result = self.registerClass(instance_class,meta_type,
permission,constructors,icon,permissions,legacy)
meta = Products.meta_types[-1]
Products.meta_types = Products.meta_types[:-1]
if len(constructors)>1:
method = constructors[1]
if type(method) is type(()):
name,method = method
else: name = method.__name__
meta['plugin_add_method'] = name
kind = instance_class.__plugin_kind__
l = PlugInKinds.get(kind, [])
l.append(meta)
PlugInKinds[kind] = l
return result
def registerPIContainerBase(self, PIC):
import sys
d = sys.modules[PIC.__module__].__dict__
self.registerZClass(d['ZClass_for_'+PIC.__name__])
# Patch ourselves in so we look like part of the Zope registration API
ProductContext.__dict__.update(_ProductContextPatch.__dict__)
class _ProductRegistryMixinPatch:
def _manage_add_plugin_meta_type(self, product, kind, meta_type, constructor_names,
permission=''):
pid = product.id
id, constructor_name = constructor_names
meta_types = self.aq_maybe('_getProductRegistryData')('plugins')
for mt in meta_types:
if mt['name']==meta_type:
raise 'Type Exists', (
'The type %s is already defined as a plug-in.'
% meta_type)
mt={
'name': meta_type,
'action': ('%s%s' % (self._constructor_prefix_string(pid), id)),
'product': pid,
'plugin_kind': kind,
'plugin_add_method': constructor_name,
}
if permission: mt['permission']=permission
meta_types = meta_types+(mt,)
self.aq_maybe('_setProductRegistryData')('plugins',meta_types)
def _manage_remove_plugin_meta_type(self, product, meta_type=None):
r=[]
pid=product.id
for mt in self.aq_maybe('_getProductRegistryData')('plugins'):
if mt.has_key('product'):
if mt['product']==pid and (
meta_type is None or meta_type==mt['name']):
continue
elif meta_type==mt['name']:
continue
r.append(mt)
self.aq_maybe('_setProductRegistryData')('plugins',tuple(r))
from App.ProductRegistry import ProductRegistry, ProductRegistryMixin
# default empty list
ProductRegistry._product_plugins=()
# Patch methods
ProductRegistryMixin.__dict__.update(_ProductRegistryMixinPatch.__dict__)
def unifiedZClassRegistry(context, filterfunc=None):
"""Return a sanely unified registry of ZClasses and ZClass bases"""
z = Products.meta_classes
i = Products.meta_class_info
r = {}
for k in z.keys():
r[k] = i[k], z[k]
for data in context.aq_acquire('_getProductRegistryData')('zclasses'):
path = '%(product)s/%(id)s' % data
r[path] = '%(product)s: %(id)s' % data, data['meta_class']
if filterfunc is not None:
for k,(i,z) in r.items():
if not filterfunc(z): del r[k]
return r
def unifiedPlugInRegistry(context, kinds):
r=[]
# Python plug-ins
for k in kinds: r.extend(PlugInKinds.get(k,[]))
# ZClass plug-ins
r.extend(list(
filter(
lambda x,kinds=kinds: x['plugin_kind'] in kinds,
context.aq_acquire('_getProductRegistryData')('plugins')
)
))
return r
from App.Factory import Factory
from App.Product import Product
class PlugInFactory(Factory):
"""Like a regular factory, but for PlugIns"""
__ac_permissions__ = Factory.__ac_permissions__
meta_type = "PlugIn Factory"
icon = "misc_/PlugIns/PlugInFactory_icon"
def __init__(self, id, title, meta_type, kind, initial, constructor, permission=''):
self.id=id
self.title=title
self.object_type=meta_type
self.kind=kind
self.initial=initial
self.constructor=constructor
self.permission=permission
def manage_edit(self, title, meta_type, kind, initial, constructor, permission='',
REQUEST=None):
"Modify factory properties."
self._unregister()
self.title=title
self.object_type=meta_type
self.kind=kind
self.initial=initial
self.constructor=constructor
self.permission=permission
self.manage_setPermissionMapping(('Use Factories',), (permission,))
self._register()
if REQUEST is not None: return self.manage_main(self, REQUEST)
def _register(self):
# Register with the product folder
product=self.aq_parent
product.aq_acquire('_manage_add_plugin_meta_type')(
product, self.kind, self.object_type, (self.initial,self.constructor),
self.permission
)
def _unregister(self):
# Unregister with the product folder
product=self.aq_parent
product.aq_acquire('_manage_remove_plugin_meta_type')(
product, self.object_type
)
manage_main=DTMLFile('editFactory',globals())
default__class_init__(PlugInFactory)
Product.manage_addPlugInFactoryForm = DTMLFile('addFactory',globals())
def manage_addPlugInFactory(
self, id, title, meta_type, kind, initial, constructor, permission=None,
REQUEST=None):
' '
i=PlugInFactory(id, title, meta_type, kind, initial, constructor, permission)
self._setObject(id,i)
if REQUEST is not None:
return self.manage_main(self,REQUEST,update_menu=1)
Product.manage_addPlugInFactory = manage_addPlugInFactory
Product.meta_types = Product.meta_types + (
{'name': PlugInFactory.meta_type, 'action':'manage_addPlugInFactoryForm'},
)
from ZClasses.ZClass import addFormDefault, addDefault
from ZClasses.ZClassOwner import ZClassOwner
import ZClasses.ZClass
def manage_addZClass(self, id, title='', baseclasses=[],
meta_type='', CreateAFactory=0,
REQUEST=None, zope_object=0):
"Add a ZClass"
ZClasses.ZClass.manage_addZClass(
self, id, title, baseclasses, meta_type, 0,
zope_object=zope_object
)
if CreateAFactory:
Z=self._getOb(id) # The meta-class
z=Z._zclass_ # The real class
meta_type = z.meta_type
self.manage_addDTMLMethod(
id+'_addForm',
id+' constructor input form',
addFormDefault % {'id': id, 'meta_type': meta_type},
)
self.manage_addPermission(
id+'_add_permission',
id+' constructor permission',
'Add %ss' % meta_type
)
if getattr(z,'__plugin_kind__',None):
self.manage_addDTMLMethod(
id+'_add',
id+' constructor',
addDefault % {'id': id}, # XXX change to our own template?
)
self.manage_addPlugInFactory(
id+'_factory',
id+' factory',
meta_type,
z.__plugin_kind__,
id+'_addForm',
id+'_add',
'Add %ss' % meta_type
)
else:
self.manage_addDTMLMethod(
id+'_add',
id+' constructor',
addDefault % {'id': id},
)
self.manage_addPrincipiaFactory(
id+'_factory',
id+' factory',
meta_type,
id+'_addForm',
'Add %ss' % meta_type
)
Z.propertysheets.permissions.manage_edit(
selected=['Add %ss' % id])
Z.manage_setPermissionMapping(
permission_names=['Create class instances'],
class_permissions=['Add %ss' % meta_type]
)
if REQUEST is not None:
return self.manage_main(self,REQUEST, update_menu=1)
Product.manage_addZClass = ZClassOwner.manage_addZClass = manage_addZClass
from OFS.PropertySheets import PropertySheet,View
from ZClasses.Property import ClassCaretaker
class PIKCaretaker(ClassCaretaker):
def __getattr__(self,name):
return ClassCaretaker.__getattr__(self,'__%s__' % name)
def __setattr__(self,name,value):
ClassCaretaker.__setattr__(self,('__%s__' % name),value)
def __delattr__(self,name):
ClassCaretaker.__delattr__(self,'__%s__' % name)
class PlugInKindSheet(PropertySheet,View):
"""ZClass class sheet for setting plug-in kind"""
_getZClass = Acquisition.Acquired
def p_self(self): return self
def v_self(self):
return PIKCaretaker(self._getZClass()._zclass_)
_properties = ({'id':'plugin_kind', 'type':'string', 'mode':'w'},)
def propertyLabel(self, id):
return {'plugin_kind':'Plug-In Kind'}.get(id,id)
def property_extensible_schema__(self): return 0
__ac_permissions__=(
('Manage Z Classes', ('', 'manage')),
)
default__class_init__(PlugInKindSheet)
class PlugInZClassSheets:
pluginKind = PlugInKindSheet('pluginKind')
class ZClass_for_PlugInBase:
propertysheets = PlugInZClassSheets()
manage_options = (
{'label': 'Plug-in Kind', 'action': 'propertysheets/pluginKind/manage'},
)
_zclass_ = PlugInBase
class ZClass_for_PlugInContainer(ZClass_for_PlugInBase):
_zclass_ = PlugInContainer
def initialize(context):
#context.registerZClass(ZClass_for_PlugInBase)
#context.registerZClass(ZClass_for_PlugInContainer)
pass
PlugIns/genericAddForm.dtml 0100644 0001752 0000627 00000001067 07543611370 015570 0 ustar roche upfront
TransactionAgents/ 0040755 0001752 0000627 00000000000 07543611544 014105 5 ustar roche upfront TransactionAgents/LICENSE 0100644 0001752 0000627 00000000015 07543611376 015106 0 ustar roche upfront same as Zope
TransactionAgents/tests/ 0040755 0001752 0000627 00000000000 07543611376 015252 5 ustar roche upfront TransactionAgents/tests/test_transactions.py 0100644 0001752 0000627 00000014311 07543611376 021370 0 ustar roche upfront from __future__ import nested_scopes
# We'll be using lots of lambda
import os, os.path, sys
try:
import unittest
except ImportError:
fix_path()
import unittest
class TestTransactions(unittest.TestCase):
def setUp(self):
# Get the Zope application object and store it in an
# instance variable for use by test methods.
import Zope
self.app=Zope.app()
def tearDown(self):
# Abort the transaction and shut down the Zope database
# connection.
get_transaction().abort()
self.app._p_jar.close()
def testSimpleRuleAgent(self):
"""This test that rule agents work, and
that they run in the order they were registered"""
l=[]
get_transaction().registerRule(
lambda: l.append('done1'))
get_transaction().registerRule(
lambda: l.append('done2'))
get_transaction().commit()
self.assertEqual(l, ['done1','done2'])
def testSimpleIndexingAgent(self):
"""This test that indexing agents work, and
that they run in the order they were registered"""
l=[]
get_transaction().registerIndex(
lambda: l.append('done1'))
get_transaction().registerIndex(
lambda: l.append('done2'))
get_transaction().commit()
self.assertEqual(l, ['done1','done2'])
def testRuleRunsBeforeIndex(self):
l=[]
get_transaction().registerIndex(
lambda: l.append('index'))
get_transaction().registerRule(
lambda: l.append('rule'))
get_transaction().commit()
self.assertEqual(l, ['rule','index'])
def addIndex(self, l, name):
"""Used by some of the tests"""
get_transaction().registerIndex(
lambda: l.append(name))
def testRuleAddsIndex(self):
"""If a rule adds an index, that index
gets added to the end of the index queue.
"""
l=[]
get_transaction().registerRule(
lambda: (l.append('rule1'), self.addIndex(l, 'index2')))
get_transaction().registerIndex(
lambda: l.append('index1'))
get_transaction().registerRule(
lambda: l.append('rule2'))
get_transaction().commit()
self.assertEqual(l, ['rule1','rule2','index1','index2'])
def testIndexAddsIndex(self):
"""If an index1 adds index2, then index2 will run
immediately after index1.
"""
l=[]
get_transaction().registerIndex(
lambda: (l.append('index1'),self.addIndex(l, 'index2')))
get_transaction().registerIndex(
lambda: l.append('index3'))
get_transaction().commit()
self.assertEqual(l, ['index1','index2','index3'])
def testBoundaryAgents(self):
"""Test that boundary agents get called on
transaction commit and transaction abort,
and also on subtransaction commit.
If a boundary agent is registered before a
subtransaction commit, it will be called at least
twice: once for the subtransaction commit, and once
for the outer transaction commit (assuming the
transaction commits successfully).
I need to think of a way of testing this for
inside the tpc.
"""
eq=self.assertEqual
l=[]
get_transaction().registerBoundaryAgent(
lambda: l.append('boundary'))
get_transaction().abort()
eq(l, ['boundary'])
l=[]
get_transaction().registerBoundaryAgent(
lambda: l.append('boundary'))
get_transaction().commit()
eq(l, ['boundary'])
l=[]
get_transaction().registerBoundaryAgent(
lambda: l.append('boundary'))
get_transaction().commit(1)
eq(l, ['boundary'])
get_transaction().commit()
eq(l, ['boundary','boundary'])
def testRulesAndIndexesWithSubtransactions(self):
"""When a subtransaction is committed while a rule agent
or indexing agent is running, agents that were added
while that rule was running are run immediately.
"""
def rule1():
l.append('rule1')
get_transaction().registerRule(
lambda: l.append('rule 1a'))
self.addIndex(l, 'index1')
get_transaction().commit(1)
self.assertEqual(l, ['rule1', 'rule 1a', 'index1'])
self.addIndex(l, 'index2')
l.append('rule1 done')
def index3():
l.append('index3')
def rule2():
l.append('rule2')
l=[]
get_transaction().registerRule(rule1)
get_transaction().registerRule(rule2)
get_transaction().registerIndex(index3)
get_transaction().registerRule(rule2)
get_transaction().commit()
self.assertEqual(l, ['rule1', 'rule 1a', 'index1', 'rule1 done',
'rule2', 'rule2', 'index3', 'index2'])
def testPostCommitAgents(self):
"""Post-commit agents run in their own transaction, which
starts immediately after the transaction they were registered
with is complete. They do not run after subtransactions.
Like with boundary agents, the system ignores any errors raised,
and logs them as warnings.
"""
pass
# TODO:
# test post-commit agents
# test errors in boundary agents and post-commit agents
# test that the queues get their state restored if there's
# an error raised while indexing agents or rule agents run.
def fix_path():
# Add Zope's lib/python directory to the Python path.
file=os.path.join(os.getcwd(), sys.argv[0])
dir=os.path.join('lib','python')
i=file.find(dir)
sys.path.insert(0, file[:i+len(dir)])
# Add the zope install directory, so we pick up ZServer.
# I need this because I'm running ZEO.
# It shouldn't do any harm otherwise.
sys.path.insert(0, file[:i])
def test_suite():
return unittest.makeSuite(TestTransactions, 'test')
def main():
unittest.TextTestRunner().run(test_suite())
if __name__=="__main__":
fix_path()
main()
TransactionAgents/version.txt 0100644 0001752 0000627 00000000056 07543611376 016334 0 ustar roche upfront TransactionAgents-0.0.2-transactionagents-005
TransactionAgents/CHANGES.txt 0100644 0001752 0000627 00000001166 07543611376 015722 0 ustar roche upfront Changes:
2 August 2001
I discovered that BoundaryAgents with ZPatterns need to run
at the end of subtransactions as well as outer transactions.
There's an odd problem that the per-transaction-cache _v_
attributes, or their contents, can get eaten up by things
that call _p_jar.cacheMinimize(3) or _p_jar.cacheFullSweep(3)
and then commit a subtransaction.
The result is that DataSkins forget about their data managers,
as the data manager didn't think it needed to set it more than
once per transaction. Actually, it needs to be set on
subtransactions.
TODO: update tests to reflect this change.
TransactionAgents/__init__.py 0100644 0001752 0000627 00000014311 07543611376 016216 0 ustar roche upfront from zLOG import WARNING
from ZODB.Transaction import Transaction
# replacements for abort, commit and __init__
def new_abort(self, subtransaction=0, freeme=1):
'''Abort the transaction.
'''
# repeated in actual abort, but kept outside for
# cleanness
if subtransaction and (self._non_st_objects is not None):
raise POSException.TransactionError, (
"""Attempted to abort a sub-transaction, but a participating
data manager doesn't support partial abort.
""")
try:
self.original_abort(subtransaction, freeme)
finally:
self.runBoundaryAgents() # ignores errors
self.newAgentQueues()
def new___init__(self, id=None):
self.original___init__(id)
# support for agents
self._boundary_agents=[]
self._post_commit_queue=[]
self._rule_queue_stack=[[]]
self._index_queue_stack=[[]]
def new_commit(self, subtransaction=None):
'Finalize the transaction'
# on an error, put the state back the way it was
# not important for Zope use, but probably useful for ZODB
original_rules=[q[:] for q in self._rule_queue_stack]
original_indexes=[q[:] for q in self._index_queue_stack]
original_post_commits=self._post_commit_queue[:]
try:
self.runRuleAgents()
self.runIndexingAgents()
except:
self._rule_queue_stack=original_rules
self._index_queue_stack=original_indexes
# a rule or index can possibly register a post-commit agent,
# so we need to restore the state to what it was.
self._post_commit_queue=original_post_commits
raise
else:
# do I really need to do this?
# probably best!
del original_rules, original_indexes, original_post_commits
try:
self.original_commit(subtransaction)
finally:
# this isn't exactly right -- it may clear the
# boundary agents when there was no transaction boundary
# if there is an exception raised in a tpc_begin,
# tpc_vote, jar.commit, commit_sub
# This is hard to get right in a simple runtime patch.
# In reality, with ZPatterns, this doesn't matter,
# as boundary agents are only used to provide
# per-transaction non-persistent attributes.
# Only run boundary agents on a proper transaction boundary.
# This makes sense for ZPatterns, and it is quite simple.
# I need more use-cases before deciding whether to do something
# more complex here.
#if not subtransaction:
self.runBoundaryAgents() # ignores errors
# these need to be run on subtransactions, because
# of _p_jar cache clearing / sweeping antics, which
# can get rid of _v_ attributes unexpectedly.
# Such antics tend to happen immediately after
# subtransaction commits.
if not subtransaction:
iq=self._post_commit_queue
self.newAgentQueues()
# only run post_commit agents on a proper (non-sub) transaction commit
if iq:
# go through list of post-commit agents
# and call each one
# ignore any exceptions
for agent in iq:
try:
agent()
except:
LOG('ZODB', WARNING,
"An post-commit agent raised an error."
"We\'re ignoring it. ",
error=sys.exc_info())
# if we changed this to run on subtransaction commits too,
# this would need to be self.commit(subtransaction)
# but we're not, so it's not
self.commit()
# new methods
def newAgentQueues(self):
# not clearAgentQueues, because elsewhere (in commit)
# I want to hang onto a reference to the _post_commit_queue
self._post_commit_queue=[]
self._boundary_agents=[]
self._rule_queue_stack=[[]]
self._index_queue_stack=[[]]
def registerPostCommit(self, agent):
if not callable(agent):
raise TypeError, "agent must be callable"
self._post_commit_queue.append(agent)
def registerRule(self, agent):
if not callable(agent):
raise TypeError, "agent must be callable"
self._rule_queue_stack[-1].append(agent)
def registerIndex(self, agent):
if not callable(agent):
raise TypeError, "agent must be callable"
self._index_queue_stack[-1].append(agent)
def registerBoundaryAgent(self, agent):
if not callable(agent):
raise TypeError, "agent must be callable"
self._boundary_agents.append(agent)
def runBoundaryAgents(self):
for agent in self._boundary_agents:
try:
agent()
except:
LOG('ZODB', WARNING,
"A boundary agent raised an error."
"We\'re ignoring it. ",
error=sys.exc_info())
# recursive
def runIndexingAgents(self):
iqs=self._index_queue_stack
my_queue=iqs[-1]
my_queue.reverse()
while my_queue:
q=[]
iqs.append(q)
agent=my_queue.pop()
agent()
if q:
self.runIndexingAgents()
iqs.pop()
# recursive
def runRuleAgents(self):
rqs=self._rule_queue_stack
iqs=self._index_queue_stack
my_queue=rqs[-1]
my_queue.reverse()
while my_queue:
q=[]
rqs.append(q)
iqs.append([])
agent=my_queue.pop()
agent()
if q:
self.runRuleAgents()
rqs.pop()
# if any indexing agents have been added, and not run
# then flatten the indexing agents stack
iq=iqs.pop()
if iq:
iqs[-1]+=iq
Transaction.original_commit=Transaction.commit
Transaction.original_abort=Transaction.abort
Transaction.original___init__=Transaction.__init__
Transaction.commit=new_commit
Transaction.abort=new_abort
Transaction.__init__=new___init__
Transaction.newAgentQueues=newAgentQueues
Transaction.registerPostCommit=registerPostCommit
Transaction.registerRule=registerRule
Transaction.registerIndex=registerIndex
Transaction.registerBoundaryAgent=registerBoundaryAgent
Transaction.runBoundaryAgents=runBoundaryAgents
Transaction.runIndexingAgents=runIndexingAgents
Transaction.runRuleAgents=runRuleAgents
ZPatterns/ 0040755 0001752 0000627 00000000000 07543611544 012410 5 ustar roche upfront ZPatterns/www/ 0040755 0001752 0000627 00000000000 07543611624 013233 5 ustar roche upfront ZPatterns/www/sheetprov.gif 0100644 0001752 0000627 00000000165 07543611361 015736 0 ustar roche upfront GIF89a @PPP ! , : # _m HP
P7I.X֙8 S݊
bΦ6xNLH ; ZPatterns/www/showCustomizers.dtml 0100644 0001752 0000627 00000001441 07543611361 017340 0 ustar roche upfront
ZPatterns/www/exprgetter.gif 0100644 0001752 0000627 00000000153 07543611361 016105 0 ustar roche upfront GIF89a @ ! , 08 0$8kj
M7
n`jbAgQ'UۄM.!E ; ZPatterns/www/acqsheetprov.gif 0100644 0001752 0000627 00000001535 07543611361 016425 0 ustar roche upfront GIF89a PPP @ @ @ @ @ ! , : H aÄ >DD &q"Ə .( #ɄOBTy#ː0 ; ZPatterns/www/PEAP.gif 0100644 0001752 0000627 00000000226 07543611361 014442 0 ustar roche upfront GIF89a @PPP ! , C0I
#, p8@`e{ Ǻ9ek ("V LfJJdu 7 ' ; ZPatterns/www/trigger.gif 0100644 0001752 0000627 00000000110 07543611361 015350 0 ustar roche upfront GIF89a ! ,
ڋ3638PUipQ p ; ZPatterns/www/rack.gif 0100644 0001752 0000627 00000000152 07543611361 014633 0 ustar roche upfront GIF89a ! , ;
{8#87ōN`Cuxztݓ@PJ*̄@@3 ; ZPatterns/www/SkinScriptMethod.gif 0100644 0001752 0000627 00000000165 07543611361 017151 0 ustar roche upfront GIF89a @ ! , :80 I8g6 CArV)k /sp+G=v%H ; ZPatterns/www/customizer.gif 0100644 0001752 0000627 00000000167 07543611361 016125 0 ustar roche upfront GIF89a ! , <8Ѿ]*\@`3 B*vީs[j~*dn6
KHHZ%tZ ; ZPatterns/www/storageForm.dtml 0100644 0001752 0000627 00000004167 07543611361 016410 0 ustar roche upfront
ZPatterns/www/acqattrprov.gif 0100644 0001752 0000627 00000000133 07543611361 016260 0 ustar roche upfront GIF89a PPP ! , dK4}C},đm$ ; ZPatterns/www/showDiagnostics.dtml 0100644 0001752 0000627 00000006507 07543611361 017270 0 ustar roche upfront
ZPatterns/www/specialist.gif 0100644 0001752 0000627 00000000164 07543611361 016056 0 ustar roche upfront GIF89a a&& ! , 98: "6od:
AtIj՞x|0 F(ٓr" ; ZPatterns/www/typesForm.dtml 0100644 0001752 0000627 00000001311 07543611361 016074 0 ustar roche upfront
ZPatterns/www/attrprov.gif 0100644 0001752 0000627 00000000170 07543611361 015574 0 ustar roche upfront GIF89a @PPP ! , = #ʨ
j@@] hirg;X10Tnwb W2UD?p|$ ; ZPatterns/www/ClassExtender.gif 0100644 0001752 0000627 00000000134 07543611361 016457 0 ustar roche upfront GIF89a ! , -TXU H b5h븩_g"= ; ZPatterns/www/custfolder.gif 0100644 0001752 0000627 00000000273 07543611361 016071 0 ustar roche upfront GIF89a @@ _ PPP ! , hI+UX٪ vt_,l b'! |v2F@88gŀ!8f]li~
˫M "AwK,/M1 ; ZPatterns/help/ 0040755 0001752 0000627 00000000000 07543611624 013337 5 ustar roche upfront ZPatterns/help/HISTORY.txt 0100644 0001752 0000627 00000026021 07543611361 015235 0 ustar roche upfront Release History
IMPORTANT NOTES FOR 0.4.2
* Zope 2.1.x support has officially ceased as of this release. DynPersist is still
required at the moment, however, and none of the 2.1.x support code has been
removed. All that's happened so far is that we're no longer coding with 2.1.x
support in mind.
* The Acquired Attribute Provider and Acquired Sheet Provider classes have been
removed, and any instances you may have in your site will show up as "broken".
Please replace them as described in the "Preparing for future versions" section
above.
* GenericAttributeProviders and GenericTriggers will be deprecated once the
SkinScript grammar has been fully documented.
Bug fixes and enhancements in 0.4.2a3
- External attribute providers now correctly advertise their "getattr"
functionality, and DataManagers should now handle internal slots correctly
even if there is an external provider providing '*'.
- SkinScript now reports syntax errors in a more meaningful way.
- Generic Attribute Providers (including those generated by SkinScript) now
report an attribute as non-existent (rather than None) if an error occurs
during their calculation.
- Triggers now have a HAS_CHANGED() function available to replace the
CHANGED() function, since CHANGED is a reserved keyword in SkinScript.
- Links to Parent Data Plug-ins should now handle the situation where the excludePIs
property is set to the wrong datatype (e.g. string instead of list/tuple).
- SkinScript methods now have a friendlier edit screen, similar to Python
Methods and DTML Methods.
Bug fixes in 0.4.2a2
- Specialists can now be placed inside other specialists. In general, adding a
PlugInContainer to another PlugInContainer did not work.
- Attribute providers which returned objects which possessed __of__ methods
(i.e. virtually all Zope objects) were broken because DynPersist called the
__of__ method without its parameters. (oops!)
- Transaction machinery was truly screwed up with respect to subtransactions.
An abort of a transaction which had a subtransaction did not actually abort,
and commiting a subtransaction could foul up important data structures.
- The SkinScript compiler removed spaces between tokens in Python expressions;
this doesn't work when "a or b" becomes "aorb", however. :( Now it places
at least one space between all tokens in the output.
- PlugIns had a missing import in its new implementation of the ObjectManager
"__replaceable__" protocol.
New Features/Bug Fixes in 0.4.2a1
- Improved SkinScript editing features, such as upload
- Added "Persistent External Attribute Provider" which allows persistent attributes
to be stored for non-persistent objects (such as items in a virtual Rack)
- All known/reported bugs from 0.4.1snap1 have been fixed
New Features/Bug Fixes in 0.4.1snap1
- SkinScript Methods let you write your object specifications in a simple
declarative language that is (of course) not yet documented. But that's
why this is a snapshot...
- Proxy settings tab for providers and triggers, where applicable, so that
you can set proxy roles.
New Features/Bug Fixes in 0.4.0alpha5
- Property Sheets for DataSkin-based ZClasses. Now you can put define
property sheets on a ZClass and still use AttributeProviders for the
properties. Just add a "DataSkin Property Sheet" to your ZClass
instead of a "Common Instance Property Sheet". (Note: you can only do
this with *new* DataSkin-derived ZClasses. If you have an already
existing ZClass, you must either re-create it by hand or do the
"setbasesholdontoyourbutts" hack to re-create the ZClass.)
- GenericTriggers now also pass a variable "ORIGINAL" which is a dictionary
of the original values of changed attributes (or NOT_FOUND if the attribute
did not exist before changing). Note that if the values are complex or
mutable, they cannot be guaranteed to be truly the same as their starting
state, so this should really only be used for simple atomic values like
strings and numbers.
- Numerous bug fixes, including:
- Specialists were always returning the result from the first Rack
- setuid support for LoginManager was broken, and also didn't deal
with executable-owner masking
- _DelAttributeFor() was broken for persistently-stored attributes
- Deleting a non-existent attribute no longer flags the attribute as changed
- _constructPlugIn() was broken with latest 2.2 version that binds constructors
to their factories
- In the latest Zope, setting ownership after adding was causing a Changed
event to fire instead of an Added event.
New Features in 0.4.0
- Attributes and Triggers
- Added the "Generic Trigger" plug-in, which executes a DTML expression
when selected (Add,Change,Delete) events occur, and can save pre-change
or pre-delete values of expressions involving the changed/deleted object,
for use in the executed expression. It can also be used as an attribute
set/delete handler.
- Added the "Generic Attribute Provider", which computes attribute values
using DTML expressions - and can call SQL or other methods to get groups
of attributes.
- Introduced support for "Agents" (triggers and indexes). Not yet fully
functional, and can't be properly supported before Zope 2.2 due to
the way transactions currently work in Zope.
- Using RackMountables outside Racks
- Added "DataSkins", which are like the old RackMountable except that they
can work in regular ZODB folders (so long as their path includes a
"Folder w/Customization Support" in it). Note that DataSkins do not support
cut-and-paste (move) under Zope versions prior to 2.2 due to an issue with
Moniker binding which is fixed in 2.2. You can use copy-and-paste, however.
- Added "Customizer" and "Folder w/Customization Support" products. Customizer
plugs into "Folder w/Customization Support" to add attributes, sheets,
triggers, and/or indexes to DataSkins contained anywhere under the
"Folder w/Customization Support".
- Racks
- Racks now cache retrieved items by key for the duration of a transaction
- Racks now support two ways to store objects: "real", by storing them in
the ZODB, and "virtual", by creating an empty object and then trying to
read a specified attribute. (If the attribute doesn't exist, the rack
considers the object not to exist.) This eliminates the need to create
subclasses of Rack to support different kinds of non-ZODB storage, since
any AttributeProvider can now be the primary source of data for an object.
- Racks offer a "getPersistentItemIDs()" method which returns the ids of
all items which have data stored persistently in the rack. (Note that
not all of these objects may exist if "virtual" storage is in use.
- Racks now can "pack" and remove unused slots (since slots can be orphaned
in "virtual" mode if an object is deleted from a foreign database).
- PlugIns
- The constructor protocols for PlugIns have been further simplified, to
the point that plugins whose add forms only ask for id and title can now
have their constructors generated automatically. See any of the places
where PlugIns (other than Racks) are registered for examples.
- Other
- There is a new "Transactions" module with handy classes for interacting with
Zope's transaction system. Subclassing 'Transactional' lets you receive
transaction-related events in your object, and the 'TransientMapping' class
lets you have a dictionary-like object that is automatically cleared after
every transaction.
API/Structural Changes in 0.4.0
- We went back to having Rack._RawItem() not being deprecated. It turned
out that it was a perfect place to ensure the new structural invariants
for DataSkins. Go figure. :)
- RackMountables became DataSkins. Please change your objects/code to get
rid of references to the RackMountable class, it will go away altogether
in 0.5.0
- The namesForRegistration() API has changed to allow Providers/Agents to
register as providing a variety of things (e.g. attributes and sheets
from the same provider).
- Attribute Providers, Sheet Providers, etc. all got merged into one tab,
"Data plug-ins", to avoid having a bunch more tabs for triggers, indexes,
etc.
Upgrading from Version 0.2.0
- ZClasses based on RackMountable and its subclasses (such as LoginUser)
may need to be recreated to take advantage of dynamic properties and
propertysheets, and possibly to work at all. You can use either the
setBasesHoldOnToYourButts method or the "make a new class and copy
stuff" method. RackMountable (or a subclass of RackMountable such as
LoginUser) **must** be listed first in your base classes to ensure
proper interaction with the new DynPersist C extension module.
New Features in 0.3.0
- DynPersist C extension that lets you put __get/set/del_attr__ hooks
on persistent objects. Used by RackMountable to support AttributeProviders.
- The Rack base class is now actually useful in its own right, providing
a persistent object store, and the ability to add arbitrary propertysheets
to RackMountables.
- Racks can now store items which are Python classes (i.e., as well as
ZClasses) as long as they register as ZClass base classes.
API/Structural Changes in 0.3.0
- The SheetProvider API has changed quite a bit, mostly because it's been
fleshed out enough to actually work. :)
- The 'PropertySheets()' and 'PropertySheet()' methods on RackMountable are
now deprecated, because the standard 'propertysheets' attribute now works
fine, even on ZClasses derived from RackMountable and its successors.
- Rack._RawItem() is deprecated in favor of Rack._v_itemConstructor() as the
preferred way of creating an "empty" RackMountable of the Rack's chosen
class. (The change is for efficiency of retrieval when using non-ZODB
data sources, since _v_itemConstructor is the cached, actual constructor
rather than a method to look up the constructor.)
- PlugIns and PlugInContainers now have a _setup() hook that gets called by
manage_afterAdd. This is intended to allow an opportunity to configure
default sub-objects such as attribute and sheet providers. If using the
_setup() hook, you should make sure it only executes once. (The Rack
_setup() method sets a self._initialized flag to keep track.)
- The PlugIn base class now subclasses SimpleItem.Item, Persistent, and
Acquisition.Implicit for you. If you need the old pure mixin class, it's
now PlugInBase.
- Many other internal structure changes occurred which we won't document
because they're things you probably shouldn't have been messing with. :)
And if you did know enough to be *able* to mess with them, you probably
won't have much trouble figuring out what we changed anyway. :)
ZPatterns/help/TODO.txt 0100644 0001752 0000627 00000003207 07543611361 014642 0 ustar roche upfront TODO: ZPatterns Development Status and Plans
General RoadMap For Future Releases
- Tutorials/API docs in a Wiki
- Help pages for all screens and objects
- Permission Mappings (for objects w/Methods tab)
- Browsing
- "Tools & Materials" concept for fields, browsers, etc.
- Support plugin-driven storage for the CMF?
Known Issues
- Undoing transactions involving multiple databases may create
inconsistencies, because ZPatterns doesn't mark the transaction
non-undoable yet.
Current Needs/To-Do Items
- SkinScript
- SkinScript SheetProvider
- INCLUDE support
- STORE attrlist IN SLOT
- DataSkins
- local role provider support (via get_local_roles_for_user)
- content/subobject provider support (to let DataSkin ObjectManagers
have contents from other databases mixed w/content from ZODB
- Improved sheets management UI on VirtualSheets
- Rack
- Class migration (handling changes of ZClass used for Rack-mounted items
that are stored persistently in ZODB).
- Need to sort out persistent internal vs. external issues when creating
a new rack.
- SheetProviders
- Permissions on SP API (Huh? Have we already done this?)
- Need nicer property labels (implement propertyLabel(id) method)
- AttributeProviders
- Need nicer property labels (implement propertyLabel(id) method)
- PlugIns
- Registration mechanism isn't well documented (as if anything in ZPatterns is!)
Cleanups
- Transactions.py: remove deprecated classes
- Expressions.py: remove push/popProxy() methods (need changes to Agents.py,
AttributeProviders.py, etc.)
ZPatterns/help/SkinScriptSyntax.stx 0100644 0001752 0000627 00000073163 07543611361 017404 0 ustar roche upfront The SkinScript Language Reference
Basic Concepts and Syntax
If you're familiar with ZPatterns, you know that DataSkins get their
attributes and behavior from AttributeProviders and RuleAgents,
respectively. Providers and Agents (known as DataPlugIns) can be
written directly in Python, but it is much easier to write them in
SkinScript. SkinScript lets you define an individual attribute
provider or rule agent in a single declarative statement, using
standard Zope tools such as SQL Methods, DTML Methods, Python
Methods, and so on to do the actual data retrieval or storage. In
effect, SkinScript is a "glue language" which lets you define the
linkages between a DataSkin and the methods you want to implement
its "skeleton" of data storage and triggered behavior.
In most languages, the order that statements appear in makes a
difference to the results you get, and SkinScript is no exception.
Although each SkinScript statement defines a seperate and
independent data plug-in, the ordering makes a difference in how
they will be used by DataSkins. When a DataSkin needs to perform
an operation (such as retrieving an attribute), it asks its
DataManager for a list of suitable DataPlugIns. This list is
ordered according to the original order of plug-ins as listed on the
Data Plug-ins tab of the Racks or Customizers involved. And the
declarations of a SkinScript Method are treated as though they were
individual plug-ins appearing in place of the SkinScript Method in
that list.
In other words, SkinScript is literally a language for defining
data plug-ins. A SkinScript *script* consists of a series of
*declarations*, seperated by whitespace. Each declaration is
compiled into a single data plug-in. SkinScript is a
keyword-driven language, is case-sensitive, and is not whitespace
sensitive, even for Python expressions contained within
declarations. All whitespace which occurs outside of quoted strings
is treated as though it were a single space. (Incidentally, this
means that the usual Python rules about where you can put linebreaks
in expressions do not apply. You can write the expression '1+2'
split across three lines, if you so desire.) Comments are marked as
in Python, using a '#' symbol to mean that the rest of the current
line is a comment. Comments are treated as simple whitespace.
Declarations
Declarations are the basic building block of SkinScript.
Declarations are compiled into AttributeProviders or RuleAgents, one
per declaration. Some declarations provide attribute values:
- 'INITIALIZE OBJECT WITH' *assignmentlist*
- 'WITH [QUERY]' *expression* 'COMPUTE' *nameorassignlist* [OTHERWISE LET assignmentlist] [DEPENDENT ON dependencies]
- 'WITH SELF COMPUTE' *assignmentlist*
Some handle attribute storage:
- [WHEN eventspec] 'STORE' *attributelist* 'USING' *expression* [ 'SAVING' *mementolist* ]
- 'STORE' *attributelist* 'IN SELF'
And others can call an expression upon transaction commit:
- 'WHEN' *eventspec* 'CALL' *expression* [ 'SAVING' *mementolist* ]
Each declaration has its own parameters, but there are certain
conventions which are followed across most kinds of declarations.
Declaration Parameters
*expression* -- A DTML-style Python expression. As with DTML, the
"_" object is available for access to Python built-ins and library
functions. Please see the section below on "Variables and Functions
Available in Expressions" for details on how names other than "_"
are looked up in SkinScript expressions.
*assignmentlist* -- A comma-seperated list of assignments in the
form *attributename* = *expression*, similar to passing keyword
arguments to a function or method.
*nameorassignlist* -- Similar to *assignmentlist*, but with a
special shorthand for the case where *attributename* and
*expression* are the same (e.g. 'foo=foo'). To make such an
assignment, you can replace *attributename* '=' *expression* with
just *attributename*. So 'foo=bar,baz=baz,bada=bing' can be
simplified to 'foo=bar,baz,bada=bing' if a clause's syntax allows a
*nameorassignmentlist*.
*mementolist* -- A *mementolist* is syntactically identical to a
*nameorassignlist*, but has a different context and purpose. A
*mementolist* is used to save old values of expressions for later
comparison purposes when a (sub)transaction commits, and appears
only in 'SAVING' clauses. Expression variables are looked up in the
context of the DataSkin whose snapshot is being taken. So in the
clause 'SAVING bar,foo=baz' the DataSkin's 'bar' attribute will be
saved as OLD['bar'], and its 'baz' attribute will be saved as
OLD['foo'].
A *mementolist* is computed only once per (sub)transaction for a
given DataSkin. The first time the DataSkin is changed in a
(sub)transaction, the 'SAVING' clause is executed for all
declarations that have one, even if the declaration never ends up
firing.
*eventspec* -- A clause of the form 'OBJECT ADDED, CHANGED,
DELETED', where the 'ADDED', 'CHANGED' and 'DELETED' keywords may be
used in any combination. For example, 'OBJECT ADDED,DELETED' and
'OBJECT CHANGED' are both valid *eventspec* clauses. Please see
HowTriggersWork for details on how ZPatterns events are interpreted
by SkinScript.
*attributelist* -- A comma-seperated list of attribute names, to
which the declaration will be applied. An asterisk ("*") may be
used as a wildcard attribute name, meaning that the declaration will
be applicable for any attribute name. Remember, however, that
declarations associated with specific names will take precedence
over wildcard declarations, even if the wildcard declaration comes
before the specific declaration and would match the name being
looked up.
*dependencies* -- A comma-seperated list of attribute names which,
when changed, will cause the dependent attributes to be recalculated
on their next access. Wildcards cannot be used, only actual
attribute names.
Variables and Functions Available in Expressions
Names used in an expression are usually looked up from the
attributes of individual SkinScript statement and its acquisition
parents (e.g. the Rack or Customizer which it's contained in, and so
on up the line). One exception to this rule is in the 'COMPUTE'
clause of a WITH/COMPUTE declaration, where names are first looked
up in the 'RESULT' object returned by the 'WITH' clause. The other
exception is in 'SAVING' clauses, where names are looked up in the
context of the DataSkin whose snapshot is being taken.
The following variable names and functions are provided by
SkinScript for use in expressions.
* Generally available:
'self' -- The DataSkin instance which the declaration is being
applied to at the time the expression is being called.
'NOT_FOUND' -- A special value which causes an attribute to be
non-existent, if this is the value provided. In a WITH/COMPUTE
declaration, if the 'WITH' expression returns 'NOT_FOUND', the
'COMPUTE' clause is ignored, and the 'OTHERWISE LET' clause is
activated if one exists.
* Available for WITH/COMPUTE declarations:
'RESULT' -- The result of the 'WITH' expression in a WITH/COMPUTE
declaration. Available only from expressions in the 'COMPUTE'
clause. This variable is placed atop the DTML namespace stack
during execution of the 'COMPUTE' clause, so just referring to a
name in a 'COMPUTE' expression will look up that name in the
'RESULT' object first. Only if it is not found there, will the
search continue to the declaration and its acquisition context.
'ATTRIBUTE_NAME' -- A string containing the name of the attribute
which the DataSkin is currently trying to retrieve. Available in
both the 'WITH' and 'COMPUTE' clauses.
* Available for WHEN/STORE and WHEN/CALL declarations:
'TRIGGER_EVENT' -- A string, either "ADD", "CHANGE", or "DELETE",
denoting the type of event which caused the expression to be
executed.
'OLD["name"]' -- 'OLD' is a mapping object containing the values
saved by the "SAVING mementolist" clause of a WHEN/STORE or
WHEN/CALL declaration.
'HAS_CHANGED("name")' -- returns a true value if the attribute
named "name" has been changed or deleted during the current
(sub)transaction.
'CHANGED_ATTRS()' -- returns a list of the names of attributes
which have been changed or deleted during the current
(sub)transaction.
'ORIGINAL["name"]' -- returns the value of the attribute named
"name" before it was changed or deleted, or the 'NOT_FOUND' value
if the attribute did not exist before this (sub)transaction. A
'KeyError' will be raised if "name" was not changed/deleted, so
use 'HAS_CHANGED()' to check before using this.
INITIALIZE OBJECT WITH *assignmentlist*
What It's For
Providing default attribute values to newly created objects.
How It Works
This declaration assigns the specified attribute values to the
object when it is created. Due to limitations of the built-in Zope
event model, it is not possible to unequivocally determine when
DataSkins outside of Racks are created, so this declaration
applies only to objects created inside Racks. The
*assignmentlist* is executed in context of the DataSkin, so later
assignments can reference the values of earlier assignments.
Examples
- Constant values::
INITIALIZE OBJECT WITH foo=1, bar='baz', degrees=360,
radians = degrees / (180 / _.math.pi)
- Defaults from properties in acquisition context::
INITIALIZE OBJECT WITH foo=myfoo, bar=mybar
WITH [ QUERY ] *expression* COMPUTE *nameorassignlist* [ OTHERWISE LET *assignmentlist* ] [ DEPENDENT ON *dependencies* ]
What It's For
Providing readable values for computed attributes and/or
attributes which are loaded from an external data source (e.g. via
an LDAP or SQL query). WITH/COMPUTE statements minimize redundant
calculations by determining some attribute values **before** they
are actually needed, as soon as one of a set of related values are
needed. This is especially important where database retrievals
are involved. It would be very bad to have to issue an SQL query
for each attribute access, even if the result was then cached. So
a WITH/COMPUTE statement executes the expensive *expression* once,
and then caches the attributes computed by the *nameorassignlist*.
Notice, by the way, that this means you can do performance tuning
by changing the grouping of attributes in your WITH/COMPUTE
statements, so that computations which are very expensive and
infrequently used are placed in standalone statements, and so on.
And if you're using data from outer-joined SQL tables, you may
even decide to split them into seperate queries (one per table)
and corresponding WITH/COMPUTE statements, if some of the tables'
data is rarely used.
How It Works
When an attribute defined in the "nameorassignlist" is requested,
call "expression". If the result of expression (available as
'RESULT' in the "nameorassignlist" expressions) is not 'NOT_FOUND',
compute all attributes from nameorassignlist, in the order they are
listed, caching the results for the remainder of the
(sub)transaction (unless later reset by a change to a 'DEPENDENT
ON' attribute).
If the 'RESULT' is 'NOT_FOUND', the search for the attribute value
falls through to the next declaration (or attribute provider if the
SkinScript is finished). If there is an 'OTHERWISE LET' clause,
the assignments given there are computed and cached for the
remainder of the (sub)transaction. (This is to prevent repeated
execution of "expression" that will only result in further
failures.)
The optional 'QUERY' keyword states that "expression" is a query
method such as an LDAP or SQL query that returns a sequence of
objects. When the 'QUERY' keyword is used, the declaration
automatically takes the first item of the sequence to be used as
'RESULT', unless the sequence is empty, in which case it behaves as
though the 'RESULT' were 'NOT_FOUND'.
The optional 'DEPENDENT ON' clause declares that the computed
attributes depend on the listed attributes for their values, and
that if any of the 'DEPENDENT ON' attributes are overwritten, the
cached values should be reset. (And thus recomputed the next time
they are accessed.) So, if for example you had a ZODB-stored field
which was a key to be looked up in an RDBMS, listing the key field
in the 'DEPENDENT ON' clause would ensure that any access to the
RDBMS-stored fields after a change in key would return data from
the correct record. (Note, however, that the attributes are *only*
reset if a 'DEPENDENT ON' attribute is changed by being *written
to*. A change in the value calculated or retrieved by another
statement or provider has no effect on the attribute cache.)
Examples
- Simple SQL query. 'SomeSQLMethod' is an SQL Method (located
somewhere in the acquisition context of this SkinScript method)
that takes 'someparam' as a parameter to return a row by primary
key, and returns a result which contains the fields 'foo', 'bar',
and 'baz', which we want to use as attributes of the same names::
WITH QUERY SomeSQLMethod(someparam=self.id) COMPUTE foo,bar,baz
- SQL query with renaming and computations. Again, notice how the
'WITH' expression is computed in the acquisition context of the
SkinScript method itself, but the 'COMPUTE' expressions are in the
context of the result of the 'WITH' expression::
WITH QUERY GetRoomData(roomname=self.id) COMPUTE
labor_cost=labor_rate*labor_hours, material_cost=materials,
height=roomdim1, width=roomdim2
- A simple computed attribute. The formula will be computed the
first time the DataSkin needs to know its 'total_cost' attribute
in a given (sub)transaction, and again if the 'labor_cost' or
'material_cost' attributes are written to::
WITH self.labor_cost + self.material_cost COMPUTE total_cost = RESULT
DEPENDENT ON labor_cost,material_cost
- Interdependent computed attributes. The first time that 'area',
'square_yards', or 'price_per_sq_yd' is asked for in a
(sub)transaction, all three will be computed (and recomputed if the
non-calculated attributes are written to)::
WITH self.width * self.height COMPUTE
area = RESULT,
square_yards = self.area / 9,
price_per_sq_yd = self.total_cost / self.square_yards
# We have to list 'real' attributes, not intermediate values!
DEPENDENT ON width,height,labor_cost,material_cost
- Object re-mapping; convert data from some object in another part
of the application. Notice that we can even save a reference to
the original object so we can call methods on it later to save our
changed attributes back into it... (And of course, we can also
seperate more expensive and less-often used attribute computations
into other WITH self.original_object COMPUTE statements)::
WITH SomeSpecialist.getItem(self.id) COMPUTE
my_foo=its_foo, my_bar=its_bar, original_object=RESULT
WITH SELF COMPUTE *nameorassignlist* [ DEPENDENT ON *dependencies* ]
What It's For
A shorthand way of defining computed attributes. This variant
form of WITH/COMPUTE simply treats 'self' as 'RESULT', placing it
on the namespace stack for the execution of the
*nameorassignlist*.
How It Works
When an attribute defined in the "nameorassignlist" is requested,
compute all attributes from nameorassignlist, in the order they are
listed, caching the results for the remainder of the
(sub)transaction (unless reset by a change to a 'DEPENDENT ON'
attribute). The DataSkin itself is placed on the namespace stack
during execution of the *nameorassignlist*, so expressions can
refer to other attributes without having to prefix them with
'self.'. 'WITH SELF COMPUTE' executes slightly faster than an
otherwise equivalent 'WITH self COMPUTE' statement, and a lot
faster than repeating 'self.foo', 'self.bar', and so on in an
expression.
The optional 'DEPENDENT ON' clause declares that the computed
attributes depend on the listed attributes for their values, and
that if any of the 'DEPENDENT ON' attributes are overwritten, the
cached values should be reset. (And thus recomputed the next time
they are accessed.) This is helpful for ensuring that
calculation-based attributes always reflect the object's current
state. Note, however, that the attributes are *only* reset if a
'DEPENDENT ON' attribute is changed by being *written to*. A
change in the value calculated or retrieved by another statement or
provider has no effect on the attribute cache.
Examples
- Simple computed attribute. The formula will be computed the first
time the DataSkin needs to know its 'total_cost' attribute in a
given (sub)transaction. Notice how much shorter this is than the
equivalent example shown under the general WITH/COMPUTE examples.
It will also execute more quickly, although by an utterly
insignificant amount::
WITH SELF COMPUTE total_cost = labor_cost+material_cost
DEPENDENT ON labor_cost,material_cost
- Interdependent computed attributes. Again, it's much less
verbose, and a hair faster than its generic WITH/COMPUTE cousin::
WITH SELF COMPUTE
area = width * height,
square_yards = area / 9,
price_per_sq_yd = total_cost / square_yards
# We have to list 'real' attributes, not intermediate values!
DEPENDENT ON width,height,labor_cost,material_cost
[ WHEN *eventspec* ] STORE *attributelist* USING *expression* [ SAVING *mementolist* ]
What It's For
Storing/updating attributes in an external data source. The
*attributelist* can contain an asterisk ('*') to mean "all
attributes".
How It Works
When an attribute listed in "attributelist" is changed/deleted, the
new value is cached in the DataSkin until a (sub)transaction
commit occurs. At that time, "expression" is called, with the
'OLD[]' variable containing the values saved by "mementolist", if
specified. (See the section above on "Declaration Parameters" for
more details on how memento lists work.)
If the optional "WHEN eventspec" clause is used, "expression" will
only be called if the eventspec matches the object-level event.
(Note that this means that if you use the WHEN clause, you will
need declarations for each possible event for each attribute to
ensure that the attributes will be saved under all possible
circumstances.)
A STORE/USING declaration is compiled into a single Data Plug-in
with two functions: to act as an attribute setter, and to act as a
rule agent. The attribute setter part simply caches changes to
attributes until (sub)transaction commit time, when the rule agent
part becomes active. The rule agent part executes the 'USING'
expression if and only if one of the 'STORE' attributes have been
changed, and the WHEN clause (if any) is applicable to the
situation as of commit time. Note that the seperation of these
parts means that the USING expression can and will be called **even
if** more than one declaration (or other Attribute Provider)
handles storage for the same attributes! This is actually quite
useful when you have data that you want updated in more than one
back-end database, but it can be surprising if you expect
first-come, only-served behavior as is the case for attribute
getters.
There is one interesting side effect, however, if a wildcard ('*')
is used in the 'STORE' list. Since the '*' matches **any**
attribute, the 'USING' expression will be called at subtransaction
commit as long as **any** attribute has changed and the 'WHEN'
clause is applicable. Again, this is a bit different from
attribute getters and other attribute setters, where '*'
effectively means "any attribute that hasn't already been claimed
by another provider."
Examples
- Context-dependent method-driven storage reusing already-written
methods. In this example, we use different methods for each
situation, which we assume are already-written and which we do not
want to change for our specific situation. Notice that for the
'ADD' and 'DELETE' events we use 'WHEN ... CALL' declarations,
because we want the widget data to be added or deleted regardless
of whether the 'foo' or 'bar' attributes have specifically
changed::
WHEN OBJECT ADDED CALL
AddWidget(widget_id=self.id, foo_field=self.foo, wbar=self.bar)
WHEN OBJECT CHANGED STORE foo,bar USING
UpdateMethod(widget_id=self.id, foo_field=self.foo, wbar=self.bar)
WHEN OBJECT DELETED CALL DeleteWidget(widget_id=self.id)
- Object remapping. This example shows how to create a "virtual"
object whose attributes 'my_foo' and 'my_bar' are mapped to/from
another object from a different specialist ('SomeSpecialist')
using the same id value, but whose fields are named 'its_foo' and
'its_bar'. The example works by maintaining an 'original_object'
attribute which contains the object from the other specialist.
This is actually a pretty simple remapping example; a single
SkinScript script might contain multiple remappings like this to
combine parts of different objects into a whole. Also, this
example assumes that we are creating an object in 'SomeSpecialist'
for every DataSkin created, while common real-life uses will often
have the 'original_object' created on demand for an existing
DataSkin, or conversely, have the DataSkin created on demand for
an existing 'original_object'::
# Handle the case where we just got created...
INITIALIZE OBJECT WITH original_object=SomeSpecialist.newItem(self.id)
# ...and the case where we already existed
WITH SomeSpecialist.getItem(self.id) COMPUTE original_object=RESULT
# Map the other object's names to mine...
WITH self.original_object COMPUTE my_foo=its_foo, my_bar=its_bar
# ...and mine to its
WHEN OBJECT ADDED,CHANGED STORE my_foo, my_bar USING
self.original_object.mange_changeProperties(
its_foo=self.my_foo, its_bar=self.my_bar
)
# Last, but not least, get rid of the other guy when I'm deleted
WHEN OBJECT DELETED CALL self.original_object.manage_delete()
- Complex storage mapping using a memento. This example
illustrates mapping a more complex kind of attribute into data
storage. 'DelKeywords' and 'AddKeywords' are methods (in the
SkinScript method's acquisition context) that delete or add
keyword records in some (unspecified) kind of database, given an
item id and a list of keywords. The example calls a method on the
DataSkin called 'getKeywords()' to extract keywords from the
'description' attribute. If the 'description' attribute is changed
during the (sub)transaction, at commit time the external database
will be updated. For illustrative purposes, appropriate WHEN/CALL
declarations are included to ensure that adds and deletes are
properly handled. Notice that the DELETED declaration uses the
value for the keywords which existed at the **start** of the
(sub)transaction, since it could theoretically have changed before
the object ended up being deleted::
WHEN OBJECT CHANGED STORE description USING
DelKeywords(item=self.id, kwlist=OLD['kw']),
AddKeywords(item=self.id, kwlist=self.getKeywords(self.description))
SAVING
kw=getKeywords(description)
WHEN OBJECT ADDED CALL
AddKeywords(item=self.id,kwlist=getKeywords(self.description))
WHEN OBJECT DELETED CALL
DelKeywords(item=self.id,kwlist=OLD['kw'])
SAVING
kw=getKeywords(description)
STORE *attributelist* IN SELF
What It's For
Specifying attributes to be stored persistently within the object.
How It Works
When an attribute listed in "attributelist" is changed/deleted, it
will be stored directly in the object as a persistent attribute.
Of course, this will only work if the object itself is stored in
the ZODB, and no previous declarations or AttributeProviders
declared storage for the attribute. "attributelist" can be just an
asterisk ('*') to indicate that all attributes not stored in some
other way should be stored persistently.
Examples
- Simple storage. The attributes 'foo', 'bar', and 'baz' will be
stored persistently in the ZODB. (Note that if the DataSkin is
stored in a Rack which is not using persistent storage, this will
not work, and data will silently be lost.)
STORE foo, bar, baz IN SELF
- Wildcard. Any attribute which is not explicitly claimed for
storage by another attribute provider/declaration will be stored
persistently, assuming that there is not another wildcard attribute
setter which appears earlier than this declaration in precedence
order.
STORE * IN SELF
WHEN *eventspec* CALL *expression* [ SAVING *mementolist* ]
What It's For
Calling an expression at (sub)transaction commit if any of the
specified events have occurred.
How It Works
At (sub)transaction commit time, if one of the events specified in
"eventspec" occurred, "expression" is called, with the 'OLD[]'
variable containing the values saved by "mementolist", if
specified.
Examples
- E-mail notification upon object add. 'EMailToManager' is a DTML
document or method in the acquisition context of the SkinScript
method, which expects a 'new_item' parameter containing the object
which the notification is supposed to be about. Note that if this
snippet were used in a Customizer, the 'ADD' event can occur when
an object is moved into the area covered by that Customizer. This
would mean notifications would be sent for objects which were not
necessarily newly created::
WHEN OBJECT ADDED CALL EMailToManager(_.None,_,new_item=self)
- Catalog example #1. This is an interesting way of doing
automatic cataloging/re-cataloging of objects without having them
be CatalogAware. Note that the order of declarations here is very
important: when an object is changed, 'uncatalog_object' will be
called before 'catalog_object'. 'SomeCatalog', of course, is a
catalog somewhere in the SkinScript method's acquisition context::
WHEN OBJECT CHANGED,DELETED CALL SomeCatalog.uncatalog_object(self.absolute_url(1))
WHEN OBJECT ADDED,CHANGED CALL SomeCatalog.catalog_object(self,self.absolute_url(1))
- Complex event alert. This example triggers if there is a 5% or
greater change in the ROI of an investment, based on any of the
input factors having changed (e.g. cashflow amounts or dates). It
works by saving the old result of the DataSkin's 'computeROI()'
method right before any change is made to the DataSkin's
attributes. The 'CALL' expression is called at (sub)transaction
commit if any changes have been made to the object. That
expression compares the new value of 'computeROI()' with the old
value as a percentage change, and if it's greater than 5%, calls
the 'SendROIAlert()' function which is somewhere in the SkinScript
method's acquisition context::
WHEN OBJECT CHANGED CALL
(abs(self.computeROI()-OLD['ROI'])/OLD['ROI'] > .05 )
and SendROIAlert(investment=self)
SAVING
ROI=computeROI()
- Catalog example #2. The previous catalog example recatalogs the
object if *any* attribute is changed, even if it is simply set back
to what it was in the first place. While future versions of
ZCatalog may optimize this case, we can do it ourselves with a bit
more complex SkinScript. This example will only recatalog the
object if attributes 'foo' or 'bar' were set or the result of
method 'baz' has changed::
WHEN OBJECT ADDED CALL SomeCatalog.catalog_object(self,self.absolute_url(1))
WHEN OBJECT DELETED CALL SomeCatalog.uncatalog_object(self.absolute_url(1))
WHEN OBJECT CHANGED CALL
(HAS_CHANGED('foo') or HAS_CHANGED('bar') or self.baz()<>OLD['baz']) and
( SomeCatalog.uncatalog_object(self.absolute_url(1)),
SomeCatalog.catalog_object(self,self.absolute_url(1))
)
SAVING baz=baz()
- Generic method-driven storage with custom method. In this
example, it is assumed that 'SomeMethod' is a DTML, SQL, or Python
method that expects to get a DataSkin and save its attributes in
an external database. The method must be smart enough to handle an
'ADD', 'CHANGE', or 'DELETE' event, and takes a parameter called
'what_happened' to tell it which one happened. In the case of an
SQL method, it's pretty straightforward to write DTML that
generates an appropriate 'INSERT', 'UPDATE', or 'DELETE' statement
according to which event happened. By using the 'HAS_CHANGED'
function, 'SomeMethod' can even generate an optimal 'UPDATE'
statement that only changes fields that have actually changed. As
you can see, this example puts the bulk of the processing burden on
'SomeMethod', which has to be written specifically for the
situation. This may be optimal, however, if you are going to have
to write the methods anyway::
WHEN OBJECT ADDED,CHANGED,DELETED CALL
SomeMethod(object=self, what_happened=TRIGGER_EVENT, has_changed=HAS_CHANGED)
Language Keywords
The following keywords are SkinScript reserved words and cannot be
used as attribute names or appear in expressions. If you must
access an attribute with one of these names in an expression, you
must use '_["name"]' syntax, as is sometimes used in DTML expressions
to access otherwise inaccessible names.
Keywords: 'ADDED CALL CHANGED COMPUTE DELETED DEPENDENT IN INCLUDE
INITIALIZE LET OBJECT ON OTHERWISE QUERY SAVING SELF SLOT STORE
USING WHEN WITH'
ZPatterns/help/CHANGES.txt 0100644 0001752 0000627 00000011226 07543611361 015145 0 ustar roche upfront Release Notes
Note: Zope 2.3.2 or better is required for this and any subsequent releases
of ZPatterns.
Changes in 0.4.3 patch 2 Release
* Fixed the manage_pack fix :(
* Added code to support Zope's deprecation of the 'id' attribute in favor
of '_getId()' and '_setId()' methods.
Changes in 0.4.3 patch 1 Release
* Fixed a stupid typo in Rack.py that caused manage_pack to delete data
* Added experimental support for Zope 2.4 (expr_globals fix)
Changes in 0.4.3 Release
* Updated management UI's to fit Zope 2.3 look-and-feel
* Added support for Zope 2.3's new BTree format in Rack objects. To convert
existing racks, just use the manage_pack method (available from the button
at the bottom of the "Storage" tab).
* Fixed manage_pack not deleting all the items it should (due to modifying
a btreeitems list in place).
* Added an optional 'DEPENDENT ON' clause to 'WITH ... COMPUTE' statements
that makes the computed variables subject to recalculation if any of the
'DEPENDENT ON' attributes are directly changed. Specifically, if an
attribute listed in the 'DEPENDENT ON' clause is set (by assignment or
'setattr()'), then the other attributes in the statement will be dropped
from the DataSkin's attribute cache, causing them to be recalculated the
next time one of them is queried.
* Fixed misc. security compatibility issues for Zope 2.3.x
Bug Fixes in 0.4.3b2
* Fixed "name" objects (shortcuts in SkinScript and elsewhere) being broken
when I updated internal docs for the b1 release. :(
IMPORTANT NOTES FOR 0.4.3b1
* The Transactions.Transactional and Transactions.TransientMapping classes are
now DEPRECATED. Use at your own risk, because they never worked 100% right
in the first place, and ZPatterns no longer uses them. They are left in as
a courtesy for the moment, but will disappear in 0.5.0.
* GenericAttributeProviders and GenericTriggers are now deprecated in favor of
SkinScript Methods, and the ability to create them has been disabled. Please
convert your existing ones over at your earliest convenience, since they will
disappear altogether in 0.5.0
New Features in 0.4.3b1
* ZClass support for PlugIns! Now you can create ZClass subclasses of PlugIns
and PlugInContainers, if their Python base classes are properly declared.
* DataSkin Class Extenders. Class extenders let you add any Zope objects you
like to a DataSkin, just by adding them on the extender's Methods tab. You
can set permission mappings on the methods, just like in a ZClass. This lets
you add methods to a DataSkin without actually altering its class. Note that
you cannot override existing methods, unless the DataSkin class defined those
methods as "class_default_for_foo" methods.
Bug Fixes/Minor Enhancements in 0.4.3b1
- The PlugIns is package is now a seperate product and can be used independently
of the rest of ZPatterns.
- Full subtransaction support. Subtransactions can be committed or aborted,
and only the correct things will be committed/rolled back. Note, however,
that anything called by your triggers must have Zope transaction support
for this to work. Right now, that probably means only ZODB and SQL data
is properly handled, and we've only done subtransaction testing with SQL
to date.
- Many new SkinScript clauses simplify common tasks such as processing an SQL
method result, providing default values if a record is not found, initializing
a newly created object, and so on. See the SkinScript documentation for details.
Upgrading from pre-0.4.x Versions
- It would be a good idea to do a "refresh" on at least one diagnostic screen
on the "Data PlugIns" tab of each DataManager derivative (Rack, Specialist,
LoginManager, UserSource, etc.) that is in an existing site.
'DataManager.__setstate__()' automatically upgrades from the old provider
registries, but we would like to get rid of this code in future releases,
so please update your objects by either refreshing a diagnostic screen on
them or by editing them in some way.
- Please get rid of any references to RackMountable, including ZClasses based
on it. RackMountable only exists for backward compatibility - it's going
to be history in 0.5.0. Derive from ZPatterns.DataSkins.DataSkin instead.
- Acquired Attribute Providers and Acquired Sheet Providers are disappearing
in favor of "Link to parent Data plug-ins", which has the features of both
and makes parent triggers active as well. 0.4.0 removes the ability to
create them; please migrate your existing ones, as in 0.5.0 the classes
will disappear.
ZPatterns/Expressions.py.original 0100644 0001752 0000627 00000011762 07543611361 017110 0 ustar roche upfront """Utilties for computing DTML (restricted Python) Expressions
This module exports everything you need to set up and call DTML expressions,
including pickle-able (but not Persistent) Expression and Name lookup
classes. The general usage pattern looks like this::
from Products.ZPatterns.Expressions import *
md = NamespaceStack() # make a namespace stack
i = InstanceDict(object, md) # prepare an object for pushing onto stack
md._push(i) # push it on the stack
getSecurityManager().addContext(self) # add owner mask/proxy roles
try:
# compute the result
result = Expression(someString).eval(md)
finally:
getSecurityManager().removeContext(self) # remove security context
md._pop() # remove pushed object
Of course, if you need to place other data on the stack, your actual code
will vary. Also, it is more likely that you will store
'Expression(someString)' as an attribute of your own objects, and simply
call its '.eval()' method when you need it, in order to avoid excessive
recompiling of the same expression.
Note: The 'pushProxy(ob)' and 'popProxy(ob)' routines are simple synonyms for
'getSecurityManager().addContext(ob)' and
'getSecurityManager().removeContext(ob)', respectively. They were originally
created to mask the differences between Zope 2.1.x and 2.2.x, and so should
be avoided when writing new code.
"""
from ExtensionClass import Base
from ComputedAttribute import ComputedAttribute
from DocumentTemplate.DT_Util import Eval, TemplateDict, InstanceDict
from AccessControl import getSecurityManager, ZopeGuards
from AccessControl.DTML import RestrictedDTML
class NamespaceStack(TemplateDict, RestrictedDTML):
"""A DTML-style namespace stack, complete with Zope security
To use, just create one with 'NamespaceStack()', then use its '_push()' and
'_pop()' methods to add/remove mapping objects. If you need to push a
regular object instance (ala DTML's "with" tag), use::
stack._push(InstanceDict(object,stack))"""
# Called by Zope only
def validate(self, inst, parent, name, value, md):
return getSecurityManager().validate(inst, parent, name, value)
def pushProxy(ob):
"""Push an object onto the security manager context stack
DEPRECATED - use 'getSecurityManager().addContext(ob)' instead"""
getSecurityManager().addContext(ob)
def popProxy(ob):
"""Pop an object from the security manager context stack
DEPRECATED - use 'getSecurityManager().removeContext(ob)' instead"""
getSecurityManager().removeContext(ob)
try:
# temporary backward hack for 2.3
from DocumentTemplate.DT_Util import expr_globals
def Eval(expr,expr_globals=expr_globals,Eval=Eval):
return Eval(expr,expr_globals)
del expr_globals
except ImportError:
pass # not needed in 2.4
class Expression(Base):
"""DTML (restricted Python) Expression object that can be pickled
To use, create with 'Expression("some string")'. You can then save the
created object as an attribute of any 'Persistent' object, and it will be
properly pickled, without writing any actual Python bytecode to the ZODB.
The secret is that the '_v_expr' computed attribute automatically recompiles
the expression whenever it's needed, but caches it while the 'Expression' is
in memory to avoid unnecessary re-compiling.
To compute the result of the expression, call its 'eval()' method, passing
in a 'NamespaceStack' object."""
def __init__(self, expr):
"""Create the expression object. 'expr' is a string."""
self.expr = expr
# Private: computed attribute for compiled form of expression
def _v_expr(self, Eval=Eval):
self._v_expr = Eval(self.expr)
return self._v_expr
_v_expr = ComputedAttribute(_v_expr)
# Private: returns pickle-able state, minus compiled expression
def __getstate__(self):
d = self.__dict__.copy()
if d.has_key('_v_expr'):
del d['_v_expr']
return d
# Private: load pickle state
def __setstate__(self, state):
d = self.__dict__
d.clear(); d.update(state)
def eval(self,mapping):
"""Return the result of computing the expression in the context of 'mapping'"""
return self._v_expr.eval(mapping)
class Name:
"""Object that does a DTML-style name lookup, with optional call of the
retrieved object"""
def __init__(self,name,call=1):
"""Create an object with the same interface as an 'Expression', but
which just looks up a name, and calls it if 'call==1'."""
self.name, self.call = name, call
def eval(self,mapping):
"""Return the result of looking up/calling the name from 'mapping'.
If the object was created with 'call==1', call it before returning it."""
return mapping.getitem(self.name,self.call)
del Eval, TemplateDict, Base, ComputedAttribute
ZPatterns/Setup 0100644 0001752 0000627 00000000133 07543611361 013422 0 ustar roche upfront *shared*
DynPersist DynPersist.c -I../../ZODB -I../../../Components/ExtensionClass/src
ZPatterns/Transactions.py 0100644 0001752 0000627 00000006230 07543611361 015425 0 ustar roche upfront """Per-Transaction Cache Management
ZPatterns objects sometimes need to reset certain cached data at transaction
boundaries. For example, DataSkins clear their attribute cache and
state flags, while Racks clear their item cache. To do this, they subclass
from 'ZPatterns.Transactions.Kept', define a '__per_transaction_cache_attrs__'
attribute listing the names of attributes they need cleared, and reference
the 'self._v_Keeper' attribute just before changing any cached attributes.
That's pretty much all that's required to make an object with per-transaction
caching capabilities.
**DO NOT USE THE DEPRECATED CLASSES**. They contain some serious bugs based on
a few critical misunderstandings of the Zope transaction state machinery, such
as the woefully misguided belief that there is any way to know whether a Zope
transaction is finished. In fact, only the Zope transaction knows if it's
finished, and it doesn't tell anybody else. :(
"""
from ExtensionClass import Base
from ComputedAttribute import ComputedAttribute
class Keeper:
"""Resets an object's per-transaction cache attributes at txn boundaries
Note that Keepers are created by Kept objects semi-automatically, and
there is usually no need to create one manually. A Keeper automatically
registers itself with the Zope transaction upon creation, and instructs
its Kept client to clear its per-transaction cache at all transaction
boundaries. Keeper methods are called only by the Zope transaction, so
don't mess with them."""
# tpc_begin, tpc_vote, commit, commit_sub: ignore
# tpc_finish, tpc_abort, abort, abort_sub: clear
def __init__(self,client):
self.client = client
get_transaction().registerBoundaryAgent(self)
def ClearCache(self,*args):
self.client._clearPerTransactionCache()
__call__=ClearCache
class Kept(Base):
"""Thing which has a Keeper to clear its per-transaction cache.
Objects derived from Kept should reference the 'self._v_Keeper'
attribute whenever they need to flag that they have made changes to
their cache that would require it to be cleared. (Note that '_v_Keeper'
is an *attribute*, not a method, and so should not be called, just
referenced.)
Once this has been done, the next transaction state transition
that occurs (sub/main transaction commit or abort) will cause
the object's Keeper to call for a cache reset.
Subclasses of Kept should define a '__per_transaction_cache_attrs__'
attribute as a sequence of attributes which they would like to have
deleted from their '__dict__' at reset time.
"""
__per_transaction_cache_attrs__ = ()
def _clearPerTransactionCache(self):
"""Get rid of stale data from previous transactions"""
d=self.__dict__; have=d.has_key
for a in self.__per_transaction_cache_attrs__:
if have(a): del d[a]
if have('_v_Keeper'): del d['_v_Keeper']
def _v_Keeper(self):
"""Our transaction keeper, which resets the cache at txn boundaries"""
v = self._v_Keeper = Keeper(self); return v
_v_Keeper = ComputedAttribute(_v_Keeper)
ZPatterns/Customizers.py 0100644 0001752 0000627 00000011427 07543611361 015310 0 ustar roche upfront from Providers import ProviderContainer
from DataManagers import DataManager
from Products.PlugIns import PlugInContainer, PlugInGroup, \
defaultConstructors, genericAddForm
from Globals import DTMLFile, default__class_init__
from OFS.Folder import Folder
_marker = []
class Customizer(DataManager):
"""DataManager for non-rackmounted DataSkins"""
__plugin_kind__ = "Customizer"
meta_type = "Customizer"
MetaTypes = ()
manage_typesForm = DTMLFile('www/typesForm', globals())
manage_options_left = (
{'label':'Customize Types','action':'manage_typesForm'},
) + DataManager.manage_options_left
def namesForRegistration(self, container):
return self.MetaTypes
def _isSelected(self, name, path, klass):
return klass._zclass_.meta_type in self.MetaTypes
def manage_setTypes(self, meta_types=(), REQUEST=None):
"""Change types applicable to this Customizer"""
self.MetaTypes = meta_types
self.aq_inner.aq_parent.manage_refreshPlugIns()
if REQUEST is not None:
return self.manage_typesForm(self, REQUEST,
manage_tabs_message="Types updated.")
__ac_permissions__ = (
('View management screens',
('manage_typesForm','manage_setTypes')
),
)
_initialized = 0
def _setup(self):
# set up default providers
if self._initialized:
# We must only initialize once, since _setup gets called on pastes,
# imports, etc.
return
from Providers import LinkToParentProviders
self._installPlugIn(
LinkToParentProviders('ParentPlugIns',
title='Plug-ins from parent Folder w/Customization Support')
)
from SheetProviders import SheetProvider
self._installPlugIn(
SheetProvider('PersistentSheets', title='Sheets stored in ZODB w/objects')
)
self._initialized = 1
class CustomizerGroup(PlugInGroup):
"""
PlugInGroup that manages the more complex registration needs
of Customizers and their containers.
"""
def _PlugInsChanged(self, container, plugins=()):
"""Update the registry of customizer names"""
custs = container.__customizerRegistry__ = {}
for plugin in plugins:
for n in plugin.namesForRegistration(container):
if not custs.has_key(n):
custs[n]=plugin
def manage_registry(self):
""" """
return self.aq_parent.__customizerRegistry__.items()
manage_below = DTMLFile('www/showCustomizers', globals())
__ac_permissions__ = (
('View management screens',
('manage_registry','manage_below')
),
)
default__class_init__(Customizer)
default__class_init__(CustomizerGroup)
class CustomizerFolder(ProviderContainer,PlugInContainer):
"""Folder which can contain objects managed by Customizers"""
Customizers_ = CustomizerGroup(
'Customizers_',
['Customizer'],
attr='__customizerList__',
title='Customizers'
)
__plugin_groups__ = (Customizers_,) + ProviderContainer.__plugin_groups__
__customizerList__ = ()
__customizerRegistry__ = {}
meta_type = "Folder w/Customizer Support"
# We want to look like a folder, but with extra tabs after 'Contents'
manage_options_left = Folder.manage_options[:1]
manage_options_right = Folder.manage_options[1:]
def _getDataManagerFor(self,client,default=None):
"""Determine data manager based on client's meta_type"""
dm = self.__customizerRegistry__.get(client.meta_type, _marker)
if dm is not _marker:
return dm.__of__(self)._getDataManagerFor(client) # forward to DM
try:
_gdmf = self.aq_inner.aq_parent.aq_acquire('_getDataManagerFor')
except AttributeError:
return default
return _gdmf(client,default)
default__class_init__(CustomizerFolder)
manage_addCustomizerFolderForm = genericAddForm(CustomizerFolder,globals())
def manage_addCustomizerFolder(self, id, title='', REQUEST=None):
"""Add a CustomizerFolder"""
self._setObject(id, CustomizerFolder(id, title))
if REQUEST: return self.manage_main(self,REQUEST,update_menu=1)
def initialize(context):
context.registerPlugInClass(
Customizer,
permission = 'Add Customizers',
constructors = defaultConstructors(Customizer,globals()),
icon = 'www/customizer.gif'
)
context.registerClass(
CustomizerFolder,
permission = 'Add Folders w/Customizer Support',
constructors = (manage_addCustomizerFolderForm,
manage_addCustomizerFolder),
icon = 'www/custfolder.gif'
)
ZPatterns/AttributeProviders.py 0100644 0001752 0000627 00000023374 07543611361 016626 0 ustar roche upfront from ComputedAttribute import ComputedAttribute
from Proxy import ProxyManager
from Products.PlugIns import defaultConstructors, PlugInContainer
from Providers import Provider, NullProvider
from Globals import default__class_init__
from string import split,strip
from Acquisition import aq_base
from Expressions import *
from ZClasses.Method import MWp
from OFS.Folder import Folder
import sys
from zLOG import LOG, WARNING
NOT_FOUND = []
eaKey = 'ZPatterns.AttributeProviders', 'ExternalAttributes'
class AttributeProvider(Provider):
"""
AttributeProvider example class. This attribute provider assumes that
the object containing the attributes is persistent and can save
whatever is desired. All of its methods would need to be redefined
for providers that implement fixed-schema and/or non-persistence-based
attributes.
"""
__plugin_kind__ = 'Attribute Provider'
def namesForRegistration(self,container):
"""
Return a tuple (readnames,writenames) where each is a sequence of attribute
names which this attribute provider supports reading and writing, respectively.
'*' may be included in either or both sequences, which means the provider will
be called if a more specific provider could not be found for a given attribute.
This is so that attribute providers can potentially create attributes
dynamically based on the requested name.
"""
return {
'provides':('attributes',),
'setattr': self.Attributes, 'delattr': self.Attributes
}
def _AttributeFor(self,client,name,default=None):
"""
Since persistent attributes are stored in the object, if we get
here, then we are trying to get something that doesn't exist!
"""
return default
def _SetAttributeFor(self,client,name,value):
"""Set the attribute and return true if successful"""
client.__dict__[name]=value; client._p_changed = 1
return 1
def _DelAttributeFor(self,client,name):
"""Delete the attribute and return true if successful"""
if client._v_changedAttrs_[name] is NOT_FOUND: del client._v_changedAttrs_[name]
return 1 # Nothing else to do, since DataSkin has already deleted persistent attr
# Class Metadata
meta_type='Persistent Internal Attribute Provider'
Attributes = ('*',)
_properties=(
{'id':'title', 'type': 'string', 'mode': 'w'},
{'id':'Attributes', 'type': 'tokens', 'mode': 'w'},
)
class ExternalAttributeProvider(AttributeProvider):
"""
This attribute provider stores persistent attributes outside the object
itself, in its persistent 'slot'. This allows persistent attributes to
be used even with non-persistent DataSkins (e.g. those which are only
virtually stored in a Rack.
"""
def _AttributeFor(self,client,name,default=None):
return client._v_readableSlot.get(eaKey,{}).get(name,default)
def _SetAttributeFor(self,client,name,value):
"""Set the attribute and return true if successful"""
attrs = client._v_readableSlot.get(eaKey,{}); attrs[name]=value
client._v_writeableSlot[eaKey] = attrs
return 1
def _DelAttributeFor(self,client,name):
"""Delete the attribute and return true if successful"""
if client._v_changedAttrs_[name] is NOT_FOUND: del client._v_changedAttrs_[name]
attrs = client._v_readableSlot.get(eaKey,{})
if attrs.has_key(name):
del attrs[name]
client._v_writeableSlot[eaKey] = attrs
return 1
# Class Metadata
meta_type='Persistent External Attribute Provider'
def namesForRegistration(self,container):
return {
'provides':('attributes',), 'getattr': self.Attributes,
'setattr': self.Attributes, 'delattr': self.Attributes
}
class ClassExtender(NullProvider,PlugInContainer):
"""Thing that provides its contents as attributes"""
__plugin_kind__ = 'Attribute Provider'
__plugin_groups__ = ()
meta_type='DataSkin Class Extender'
manage_options_right = tuple(
Folder.manage_options[1:-3]+(
{'label':'Security','action':'manage_access',
'help':('OFSP','Security.stx'),},
)+Folder.manage_options[-2:]
)
def namesForRegistration(self,container):
return {
'provides':('attributes',),
'getattr': self.objectIds(),
}
def _AttributeFor(self,client,name,default=None):
return MWp(self.__dict__.get(name,default))
def _SetAttributeFor(self,client,name,value):
pass
def _DelAttributeFor(self,client,name):
pass
def _setObject(self,id,object,roles=None,user=None, set_owner=1):
r = PlugInContainer._setObject.im_func(self,id,object,roles,user,set_owner)
self.aq_inner.aq_parent.manage_refreshPlugIns()
return r
def _delObject(self, id, dp=1):
PlugInContainer._delObject.im_func(self,id,dp)
self.aq_inner.aq_parent.manage_refreshPlugIns()
# Permission mapping stuff
def permissionMappingPossibleValues(self):
return self.possible_permissions()
_isBeingUsedAsAMethod_=1
def _isBeingUsedAsAMethod(self, REQUEST=None, wannaBe=0):
if REQUEST is not None and wannaBe: REQUEST.response.notFoundError()
return 0
class GAPMixin:
def namesForRegistration(self,container):
"""XXX"""
d={}
for attr in self.Attributes: d[attr[0]]=1
for attr in self.Defaults: d[attr[0]]=1
return {
'provides': ('attributes',),
'getattr': d.keys()
}
Attributes = ()
Defaults = ()
IsQuery = None
dependencies=()
def _AttributeFor(self,client,name,default=None):
try:
t = NamespaceStack()
pushProxy(self)
try:
data = {'self':client, 'ATTRIBUTE_NAME':name, 'NOT_FOUND':default}
if self._fromex is not None:
t._push(InstanceDict(self, t))
t._push(data)
try:
result = data['RESULT'] = self._fromex.eval(t)
finally:
t._pop(2)
if self.IsQuery:
if len(result):
result=result[0]
else:
result=default
else:
# use 'self' as result
result = data['RESULT'] = client
if result is default:
exprlist = self.Defaults
else:
exprlist = self.Attributes
if not exprlist:
return default
t._push(InstanceDict(result, t))
t._push(data)
try:
c = client._getCache()
sd = client._setDependencies
deps = self.dependencies
for a,e in exprlist:
# we set dependencies before each one so they'll
# still be set, and up through however far we got
if deps: sd(a,deps)
c[a] = e.eval(t)
finally:
t._pop(2)
finally:
popProxy(self)
return c.get(name,default)
except:
LOG('ZPatterns',WARNING,('Error computing attribute %s' % name),
'', sys.exc_info(), 1)
return default
class GenericAttributeProvider(GAPMixin,AttributeProvider,ProxyManager):
"""
XXX Explain this
"""
manage_options = AttributeProvider.manage_options + ProxyManager.manage_options
def _propertiesChanged(self):
self.Attributes = []
if self.fromexpr:
self._fromex = Expression(self.fromexpr)
else:
self._fromex = None
for l in filter(None,map(strip,self.attrsexprs)):
if '=' in l:
a,e = split(l,'=',1)
self.Attributes.append(a,Expression(e))
else:
self.Attributes.append(l,Name(l,0))
# Class Metadata
meta_type='Generic Attribute Provider'
fromexpr=''
attrsexprs=[]
_properties=(
{'id':'title', 'type': 'string', 'mode': 'w'},
{'id':'fromexpr', 'type': 'string', 'mode': 'w'},
{'id':'attrsexprs', 'type': 'lines', 'mode': 'w'},
)
ExprGetterAttributeProvider = GenericAttributeProvider
def initialize(context):
context.registerPlugInClass(
AttributeProvider,
permission = 'Add Attribute Providers',
constructors = defaultConstructors(AttributeProvider,globals()),
icon = 'www/attrprov.gif'
)
context.registerPlugInClass(
ClassExtender,
permission = 'Add DataSkin Class Extenders',
constructors = defaultConstructors(ClassExtender,globals()),
icon = 'www/ClassExtender.gif'
)
context.registerPlugInClass(
ExternalAttributeProvider,
permission = 'Add Attribute Providers',
constructors = defaultConstructors(ExternalAttributeProvider,globals()),
icon = 'www/PEAP.gif'
)
return
# disabled
context.registerPlugInClass(
GenericAttributeProvider,
permission = 'Add Generic Attribute Providers',
constructors = defaultConstructors(GenericAttributeProvider,
globals()),
icon = 'www/exprgetter.gif'
)
ZPatterns/SheetProviders.py 0100644 0001752 0000627 00000006777 07543611361 015743 0 ustar roche upfront from OFS.PropertySheets import PropertySheet
from Providers import Provider
from Globals import default__class_init__
from Products.PlugIns import defaultConstructors
psKey = 'ZPatterns.SheetProviders', 'PropertySheets'
class SheetProvider(Provider):
"""
Sheet provider example class. This sheet provider uses the 'slot'
facility of Racks/Rackmountables to provide arbitrary propertysheets
stored persistently. All of its methods would need to be redefined
for SheetProviders that implement fixed-schema and/or non-slot-based
property sheets.
"""
__plugin_kind__ = 'Property Sheet Provider'
def namesForRegistration(self,container):
"""
Return a tuple (names,namespaces) where names is a sequence of
sheet names, and namespaces a sequence of XML namespaces, which this sheet
provider supports. '*' may be included in either or both sequences, which
means the provider will be called if a more specific provider could not
be found for a given sheet. This is mainly so that sheet providers can
potentially create propertysheets dynamically based on the requested name
or namespace.
"""
return {
'provides': ('sheets',),
'sheet_names': self.Sheet_Names,
'sheet_xmlns': self.Sheet_Namespaces
}
def _PropertySheetFor(self,client,name='',xmlns=''):
"""
Return client's propertysheet matching name or xmlns, if available.
Otherwise return None.
"""
pslist = client._v_readableSlot.get(psKey,())
for ps in pslist:
if (name and ps.id==name) or (xmlns and ps.xml_namespace()==xmlns):
return ps
def _addPropertySheetFor(self,client,name='',xmlns=''):
"""
Return client's new propertysheet matching name or xmlns, if possible.
Otherwise return None.
"""
ps=PropertySheet(name, {'xmlns':xmlns})
pslist = client._v_readableSlot.get(psKey,())+(ps,)
client._v_writeableSlot[psKey] = pslist
return ps
def _delPropertySheetFor(self,client,name='',xmlns=''):
"""
Delete client's propertysheet matching name or xmlns, if present.
Always returns None (unless an unexpected error occurs, of course)
"""
pslist = client._v_readableSlot.get(psKey,())
newlist = tuple(filter(
lambda ps,name=name,xmlns=xmlns:
(not name or ps.id!=name) and
(not xmlns or ps.xml_namespace()!=xmlns),
pslist
))
if newlist!=pslist:
client._v_writeableSlot[psKey] = newlist
def _PropertySheetsFor(self, client):
"""Return a (possibly empty) list of PropertySheet objects for client"""
# Note: this could include duplicate sheets if persistent sheets
# are defined by more than one provider!
return client._v_readableSlot.get(psKey,())
# Class Metadata
meta_type='Persistent Sheet Provider'
Sheet_Names = ('*',)
Sheet_Namespaces = ('*',)
_properties=(
{'id':'title', 'type': 'string', 'mode': 'w'},
{'id':'Sheet_Names', 'type': 'tokens', 'mode': 'w'},
{'id':'Sheet_Namespaces', 'type': 'lines', 'mode': 'w'},
)
def initialize(context):
context.registerPlugInClass(
SheetProvider,
permission = 'Add Sheet Providers',
constructors = defaultConstructors(SheetProvider,globals()),
icon = 'www/sheetprov.gif'
)
ZPatterns/Expressions.py 0100644 0001752 0000627 00000011767 07543611361 015312 0 ustar roche upfront """Utilties for computing DTML (restricted Python) Expressions
This module exports everything you need to set up and call DTML expressions,
including pickle-able (but not Persistent) Expression and Name lookup
classes. The general usage pattern looks like this::
from Products.ZPatterns.Expressions import *
md = NamespaceStack() # make a namespace stack
i = InstanceDict(object, md) # prepare an object for pushing onto stack
md._push(i) # push it on the stack
getSecurityManager().addContext(self) # add owner mask/proxy roles
try:
# compute the result
result = Expression(someString).eval(md)
finally:
getSecurityManager().removeContext(self) # remove security context
md._pop() # remove pushed object
Of course, if you need to place other data on the stack, your actual code
will vary. Also, it is more likely that you will store
'Expression(someString)' as an attribute of your own objects, and simply
call its '.eval()' method when you need it, in order to avoid excessive
recompiling of the same expression.
Note: The 'pushProxy(ob)' and 'popProxy(ob)' routines are simple synonyms for
'getSecurityManager().addContext(ob)' and
'getSecurityManager().removeContext(ob)', respectively. They were originally
created to mask the differences between Zope 2.1.x and 2.2.x, and so should
be avoided when writing new code.
"""
from ExtensionClass import Base
from ComputedAttribute import ComputedAttribute
from DocumentTemplate.DT_Util import Eval, TemplateDict, InstanceDict
from AccessControl import getSecurityManager, ZopeGuards
from AccessControl.DTML import RestrictedDTML
class NamespaceStack(TemplateDict, RestrictedDTML):
"""A DTML-style namespace stack, complete with Zope security
To use, just create one with 'NamespaceStack()', then use its '_push()' and
'_pop()' methods to add/remove mapping objects. If you need to push a
regular object instance (ala DTML's "with" tag), use::
stack._push(InstanceDict(object,stack))"""
# Called by Zope only
def validate(self, inst, parent, name, value, md=None):
return getSecurityManager().validate(inst, parent, name, value)
def pushProxy(ob):
"""Push an object onto the security manager context stack
DEPRECATED - use 'getSecurityManager().addContext(ob)' instead"""
getSecurityManager().addContext(ob)
def popProxy(ob):
"""Pop an object from the security manager context stack
DEPRECATED - use 'getSecurityManager().removeContext(ob)' instead"""
getSecurityManager().removeContext(ob)
try:
# temporary backward hack for 2.3
from DocumentTemplate.DT_Util import expr_globals
def Eval(expr,expr_globals=expr_globals,Eval=Eval):
return Eval(expr,expr_globals)
del expr_globals
except ImportError:
pass # not needed in 2.4
class Expression(Base):
"""DTML (restricted Python) Expression object that can be pickled
To use, create with 'Expression("some string")'. You can then save the
created object as an attribute of any 'Persistent' object, and it will be
properly pickled, without writing any actual Python bytecode to the ZODB.
The secret is that the '_v_expr' computed attribute automatically recompiles
the expression whenever it's needed, but caches it while the 'Expression' is
in memory to avoid unnecessary re-compiling.
To compute the result of the expression, call its 'eval()' method, passing
in a 'NamespaceStack' object."""
def __init__(self, expr):
"""Create the expression object. 'expr' is a string."""
self.expr = expr
# Private: computed attribute for compiled form of expression
def _v_expr(self, Eval=Eval):
self._v_expr = Eval(self.expr)
return self._v_expr
_v_expr = ComputedAttribute(_v_expr)
# Private: returns pickle-able state, minus compiled expression
def __getstate__(self):
d = self.__dict__.copy()
if d.has_key('_v_expr'):
del d['_v_expr']
return d
# Private: load pickle state
def __setstate__(self, state):
d = self.__dict__
d.clear(); d.update(state)
def eval(self,mapping):
"""Return the result of computing the expression in the context of 'mapping'"""
return self._v_expr.eval(mapping)
class Name:
"""Object that does a DTML-style name lookup, with optional call of the
retrieved object"""
def __init__(self,name,call=1):
"""Create an object with the same interface as an 'Expression', but
which just looks up a name, and calls it if 'call==1'."""
self.name, self.call = name, call
def eval(self,mapping):
"""Return the result of looking up/calling the name from 'mapping'.
If the object was created with 'call==1', call it before returning it."""
return mapping.getitem(self.name,self.call)
del Eval, TemplateDict, Base, ComputedAttribute
ZPatterns/Specialists.py 0100644 0001752 0000627 00000004773 07543611361 015252 0 ustar roche upfront from Products.PlugIns import PlugInGroup, PlugInContainer, PlugInFinder, MakePICBase
from Providers import ProviderContainer
from Globals import DTMLFile, default__class_init__
_marker = []
class Specialist(ProviderContainer, PlugInContainer):
"""Specialist - provides implementation services for an abstract type"""
meta_type = "Specialist"
RacksGroup = PlugInGroup('RacksGroup',['Rack'],
attr='rackList', title='Racks')
__plugin_groups__ = (RacksGroup,) + ProviderContainer.__plugin_groups__
rackList = ()
def __bobo_traverse__(self, REQUEST, name):
ob = getattr(self, name, _marker)
if ob is _marker:
ob = self.getItem(name)
if ob is not None:
return ob
raise 'NotFound'
return ob
def getItem(self, key):
"""Get an item"""
if hasattr(self.aq_base,'retrieveItem'):
return self.retrieveItem(key=key) # XXX need DTML check?
for rack in self.rackList:
item = rack.__of__(self).getItem(key)
if item is not None: return item
def newItem(self, key=None):
"""Create a new item"""
# Default use first rack
return self.rackList[0].__of__(self).newItem(key)
def manage_refreshPlugIns(self, REQUEST=None):
"""Update plugin registries"""
r = PlugInContainer.manage_refreshPlugIns(self,REQUEST)
# Pass on word to the racks
for rack in self.rackList:
rack.__of__(self).manage_refreshPlugIns()
return r
__ac_permissions__ = (
('Access contents information', ('getItem',)),
('Add Items to Racks', ('newItem',)),
)
default__class_init__(Specialist); MakePICBase(Specialist)
manage_addSpecialistForm = DTMLFile('addSpecialist', globals(),
RacksMetaTypes = PlugInFinder(Specialist.RacksGroup))
def manage_addSpecialist(self, id, title='', rack='', REQUEST=None):
"""Add a Specialist"""
ob = Specialist(id, title)
self._setObject(id, ob)
ob = ob.__of__(self)
if rack:
ob.RacksGroup._constructPlugIn(rack, id='defaultRack')
if REQUEST: return self.manage_main(self,REQUEST,update_menu=1)
def initialize(context):
context.registerPIContainerBase(Specialist)
context.registerClass(
Specialist,
permission = 'Add Specialists',
constructors = (manage_addSpecialistForm,
manage_addSpecialist),
icon = 'www/specialist.gif',
)
ZPatterns/Rack.py 0100644 0001752 0000627 00000026633 07543611361 013646 0 ustar roche upfront from DataManagers import DataManager
from SheetProviders import SheetProvider
from AttributeProviders import AttributeProvider
from Providers import LinkToParentProviders
from Globals import DTMLFile, default__class_init__, PersistentMapping
from ComputedAttribute import ComputedAttribute
from Transactions import Kept
from DataSkins import DataSkin
from Products.PlugIns import MakePICBase
import Products
_marker=[]
SelfKey = 'ZPatterns.Rack','Self'
class Rack(DataManager, Kept):
"""
Basic Rack - supports sheet and attribute provider plugins, as
well as persistent storage of any ZClass object and arbitrary
associated data (using "slots").
"""
# Template (i.e. abstract) methods, should be left as-is
def getItem(self, key):
"""Get an item from the rack by key"""
# Borrow canonicals map for per-transaction item cache
item = self._fromCache(key,_marker)
if item is _marker:
item = self.retrieveItem(key)
self._toCache(key,item) # XXX Should we cache non-existence?
return item
def newItem(self, key=None):
"""Create a new item - attempts to generate key if not supplied"""
if key is None:
key=getattr(self,'newKey',None)
key=key and key()
if key is None: return None
return self.createItem(key)
def _objectDeleting(self,client):
DataManager._objectDeleting(self,client)
self._delSlotFor(client)
# Methods to be overridden in subclasses for non-ZODB storage
loadAttrib = '' # If not empty, attribute to use when loading an item
def retrieveItem(self,key):
# Retrieve an object, identified by key
a = self.loadAttrib
item = None
if a:
item = self._RawItem(key)
if hasattr(item.aq_base, a):
return item
else:
# The block below is what you want to replace
# if you're creating a non-ZODB storage.
# In practice, from version 0.4.0 on, there's
# no reason to do such a thing in the first place.
slot = self._readableSlot(key)
if slot:
item = slot[SelfKey]
# XXX class remapping should go here??
self = self.aq_inner
item._setRack(self)
item._setSlot(slot)
return item.__of__(self.aq_parent)
def createItem(self,key):
# Create a new object, identified by key
item = self.getItem(key)
# XXX What if all items potentially exist?
if item is not None:
raise KeyError,("'%s' already exists" % key)
item = self._RawItem(key)
a = self.loadAttrib
if not a:
slot = self._writeableSlot(key)
slot[SelfKey] = item.aq_base # strip acquisition wrapping
item._setSlot(slot) # Not needed for non-ZODB storage
item._objectCreating()
item._objectAdding()
self._toCache(key,item) # XXX Should we cache non-creation?
return item
# Optionally overrideable methods for additional functionality
#def newKey(self):
# """Generate a new object key"""
# pass # must be defined if key autogeneration is desired
#
# def countItems(self): pass
# def deleteAll(self): pass
_initialized = 0
def _setup(self):
# set up default providers
if self._initialized:
# We must only initialize once, since _setup gets called on pastes,
# imports, etc.
return
self._installPlugIn(
LinkToParentProviders('SpecialistPlugIns',
title='Plug-ins from parent Specialist')
)
self._installPlugIn(
SheetProvider('PersistentSheets', title='Sheets stored in Rack slots')
)
self._installPlugIn(
AttributeProvider('PersistentAttributes',
title='Attributes stored persistently in objects')
)
self._initialized = 1
# ZClass Machinery (Optionally overrideable)
_defaultClass = None
def _v_itemConstructor(self):
c = getattr(self, '_zclass', None) or self._defaultClass
if c:
if type(c) is type(''):
c = self._unifiedZClassRegistry()[c][1] #Products.meta_classes[c]
else:
def err(key):
raise TypeError, "No ZClass set - please use 'Storage' tab"
return err
c = getattr(c,'_zclass_',c)
self._v_itemConstructor = c
return c
_v_itemConstructor = ComputedAttribute(lambda s,v=ComputedAttribute(_v_itemConstructor): v)
def _RawItem(self, key):
"""
Create an empty object of the right class
"""
self = self.aq_inner
item = self._v_itemConstructor()
item._setRack(self) # Connect to rack
item = item.__of__(self.aq_parent.aq_inner) # Link to Specialist
item._setId(key)
return item
def _isSelected(self, name, path, klass):
Z = self._v_itemConstructor
Z = getattr(Z, 'aq_self', Z)
return klass._zclass_ is Z
# Caching
def _v_cache(self):
self._v_Keeper
l = self._v_cache = {}
return l
_v_cache = ComputedAttribute(_v_cache)
__per_transaction_cache_attrs__ = ('_v_cache',)
def _fromCache(self, key, default=None):
return self._v_cache.get(key,default)
def _toCache(self, key, item):
self._v_cache[key] = item
# Persistence Machinery - little need to override, but to be extended
# for future multi-ZODB support
storageInfo = '' # Reserved for configuring future multi-ZODB support
__storage = None # This rack's storage object for sheets and/or objects
def storageInUse(self):
"""How many racked items have persistent storage use?"""
return len(self.__readableStorage)
def __writeableStorage(self):
"""Create new a mapping-like object for storing 'persistent' stuff and save it in self"""
from BTrees.OOBTree import OOBTree
s = self.__readableStorage = self.__writeableStorage = OOBTree()
return s
__readableStorage = {}
__writeableStorage = ComputedAttribute(__writeableStorage)
def _migrateStorage(self,storage):
"""Move existing data to new kind of storage"""
#if self.storageInUse():
# raise ValueError, "Cannot change storage with contents present"
raise "NotImplemented", "Only self-storage is currently supported"
# XXX self.storageInfo = storage; del self.__storage
def manage_storageOptions(self):
"""Return a list of key-value pair tuples listing storage options"""
return [('', 'Directly in this object')]
def _getClientID(self,client):
return client.getId()
def _readableSlotFor(self, client):
slot = self._readableSlot(self._getClientID(client),_marker)
if slot is not _marker:
client._setSlot(slot)
return slot
else:
return {}
def _writeableSlotFor(self, client):
slot = self._writeableSlot(self._getClientID(client))
client._setSlot(slot)
return slot
def _readableSlot(self, key, default={}):
return self.__readableStorage.get(key,default)
def _writeableSlot(self, key):
r = self.__writeableStorage.get(key,_marker)
if r is _marker:
r = self.__writeableStorage[key] = PersistentMapping()
return r
def _delSlotFor(self, client):
"""Delete persistent mapping for client, if present"""
id = self._getClientID(client)
if self.__readableStorage.has_key(id): del self.__writeableStorage[id]
def getPersistentItemIDs(self):
return self.__readableStorage.keys()
# Management interface
manage_storageForm = DTMLFile('www/storageForm', globals())
def manage_setStorage(self, zclass=None, storage=None, use_attrib=None, \
load_attrib=None, REQUEST=None):
"""
Change class of returned items, and persistent storage used
to store them
"""
if zclass is not None:
if self._unifiedZClassRegistry().has_key(zclass):
#if Products.meta_classes.has_key(zclass):
self._zclass = zclass
#else:
# self._zclass = self._unifiedZClassRegistry()[zclass][1]
if self.__dict__.has_key('_v_itemConstructor'):
del self._v_itemConstructor
else:
raise NameError,("Invalid/nonexistent ZClass '%s'" % zclass)
if storage is not None and storage != self.storageInfo:
self._migrateStorage(storage)
if use_attrib is not None and load_attrib is not None:
self.loadAttrib = (use_attrib=="YES") and load_attrib or ""
if REQUEST is not None:
return self.manage_storageForm(self, REQUEST,
manage_tabs_message='Updated storage settings.')
def manage_pack(self,REQUEST=None):
"""Pack storage by copying to new storage and skipping unused objects"""
if self.__readableStorage:
old = self.__writeableStorage
del self.__writeableStorage # force a new one to be created
new = self.__writeableStorage
self.__readableStorage = old
c=0
for k,v in old.items():
if self.getItem(k) is None: continue
new[k]=v
c=(c+1) % 1000
if not c:
get_transaction().commit(1)
old._p_jar.cacheMinimize(3)
self.__readableStorage = new
get_transaction().commit(1)
old._p_jar.cacheMinimize(3)
if REQUEST is not None:
return self.manage_storageForm(self, REQUEST,
manage_tabs_message='Pack completed.')
manage_options_right = (
{'label':'Storage',
'action':'manage_storageForm'},
) + DataManager.manage_options_right
meta_type = "Rack"
__plugin_kind__ = "Rack"
icon = 'misc_/ZPatterns/rack'
__ac_permissions__ = (
('Change Rack storage settings',
('manage_storageForm','manage_setStorage','manage_storageOptions',
'manage_pack'),
),
('Access contents information',
('getItem','retrieveItem','storageInUse','getPersistentItemIDs'),
),
('Add Items to Racks', ('newItem','createItem','newKey'), ),
)
default__class_init__(Rack); MakePICBase(Rack)
manage_addRackForm = DTMLFile('addRack', globals())
def manage_addRack(self, id, title='', REQUEST=None):
"""Add a Rack"""
ob = Rack(id, title)
return self.Destination()._installPlugIn(ob,'Added Rack.',REQUEST)
class RackMountable(DataSkin):
meta_type="Rack-mountable"
def initialize(context):
context.registerPlugInClass(
Rack,
permission = 'Add Racks',
constructors = (manage_addRackForm,
manage_addRack),
icon = 'www/rack.gif',
)
context.registerPIContainerBase(Rack)
ZPatterns/version.txt 0100644 0001752 0000627 00000000052 07543611361 014625 0 ustar roche upfront ZedPatterns-0-4-3p2-transactionagents-005
ZPatterns/DataManagers.py 0100644 0001752 0000627 00000007040 07543611361 015304 0 ustar roche upfront from Providers import ProviderGroup, ProviderContainer
from Products.PlugIns import PlugInContainer, unifiedZClassRegistry
from Globals import default__class_init__, PersistentMapping
from OFS.Folder import Folder
from ComputedAttribute import ComputedAttribute
from AttributeProviders import AttributeProvider
from SheetProviders import SheetProvider
from ExtensionClass import Base
import Products
try:
from thread import get_ident
except:
def get_ident(): pass
_marker = []
class DataManager(ProviderContainer, PlugInContainer):
"""Something which provides objects with data"""
def _objectChanging(self,client):
for ob in self._getRegistry('provides').get('handlers',()):
ob.__of__(self)._objectChanging(client)
def _objectCreating(self,client):
for ob in self._uniqueProviders(('attributes','sheets','handlers')):
ob._objectCreating(client)
def _objectAdding(self,client):
for ob in self._uniqueProviders(('attributes','sheets','handlers')):
ob._objectAdding(client)
def _objectDeleting(self,client):
for ob in self._uniqueProviders(('handlers','sheets','attributes')):
ob._objectDeleting(client)
def _getDataManagerFor(self,client,default=None):
return self.aq_inner
def _readableSlotFor(self,client):
slot = client.__dict__.get('__skinSlot__',_marker)
if slot is _marker: return {}
client._setSlot(slot); return slot
def _writeableSlotFor(self,client):
slot = client.__dict__.get('__skinSlot__',_marker)
if slot is _marker:
slot = client.__dict__['__skinSlot__'] = PersistentMapping()
client._p_changed = 1
client._setSlot(slot); return slot
def _zclassOK(self, z):
"""Verify that the ZClass selected is acceptable for this DataManager"""
# All we check here is rack-mountability/dataskinnishness
return getattr(z._zclass_,'_isRackMountable',0)
def _unifiedZClassRegistry(self):
"""Return a sanely unified registry of ZClasses and ZClass bases"""
return unifiedZClassRegistry(self, self._zclassOK)
def manage_product_zclass_info(self):
"""Return a list of ZClasses suitable for use in this DataManager"""
return map(lambda x, sel=self._isSelected: {
'name':x[1][0],
'path':x[0],
'meta_type': x[1][1]._zclass_.meta_type,
'selected': sel(x[1][0],x[0],x[1][1]) and 'selected' or '',
},
self._unifiedZClassRegistry().items()
)
def _isSelected(self,name,path,klass): pass
__ac_permissions__ = (
('View management screens',
('manage_product_zclass_info',),
),
)
default__class_init__(DataManager)
_nullDMs = {}
class DefaultDataManager(Base):
"""Thing that returns a canonical NullDataManager for each thread"""
def __of__(self,parent):
id = get_ident()
NDM = _nullDMs.get(id)
if NDM is None:
NDM = _nullDMs[id] = NullDataManager(id='_DefaultDataManager')
return NDM.__of__(parent)
class NullDataManager(DataManager):
"""DataManager that emulates ordinary Zope reality"""
def _objectDeleting(self,client): pass
def _objectChanging(self,client): pass
def _objectCreating(self,client): pass
def _objectAdding(self,client): pass
def _getProvidersFor(self,client,kind,names): return ()
def _uniqueProviders(self,kinds): return ()
ZPatterns/addRack.dtml 0100644 0001752 0000627 00000001215 07543611361 014614 0 ustar roche upfront
ZPatterns/documentProxy.dtml 0100644 0001752 0000627 00000002332 07543611361 016144 0 ustar roche upfront
Proxy roles allow you to control the access that an object has when
it executes. Proxy roles replace the roles of the user who is causing
the object to be executed. This can be used to both expand and limit
access to resources. Select the proxy roles for this object from
the list below.
ZPatterns/PropertySheets.py 0100644 0001752 0000627 00000005623 07543611361 015762 0 ustar roche upfront import OFS.PropertySheets
from ComputedAttribute import ComputedAttribute
from Globals import default__class_init__, Dictionary
from ZClasses.Property import klass_sequence, ClassCaretaker, ZCommonSheet
class VirtualSheets(OFS.PropertySheets.PropertySheets):
"""Ensure that virtual propertysheets are included in sheets"""
def __propsets__(self):
propsets = self._get_defaults()+self.aq_inner.aq_parent._v_currentSheets
r=[]
for id in klass_sequence(self.__class__,'__propset_attrs__').keys():
r.append(getattr(self,id))
return propsets+tuple(r)
def get(self,name,default=None):
for propset in self._get_defaults():
if propset.id==name or propset.xml_namespace()==name:
return propset.__of__(self)
client = self.aq_inner.aq_parent
s = client._delegateToSheetProviders(name,name,'_PropertySheetFor')
if s is not None: return s.__of__(self)
return default
def __bobo_traverse__(self, REQUEST, name=None):
for propset in self._get_defaults():
if propset.id==name:
return propset.__of__(self)
client = self.aq_inner.aq_parent
s = client._delegateToSheetProviders(name,'','_PropertySheetFor')
if s is not None: return s.__of__(self)
return getattr(self, name)
def manage_addPropertySheet(self, id, ns):
""" """
if self.aq_inner.aq_parent._addPropertySheet(id,ns):
return 'OK'
def manage_delPropertySheet(self, name='', xmlns=''):
""" """
self.aq_inner.aq_parent._delPropertySheet(name,xmlns)
return 'OK'
__ac_permissions__ = (
("Manage properties",
('manage_addPropertySheet','manage_delPropertySheet')
),
)
_implements_the_notional_subclassable_propertysheet_class_interface=1
def propertyLabel(self,id):
return id # Hack to make sheets UI work
default__class_init__(VirtualSheets)
# ZClass propertysheet helpers
class DefaultCaretaker(ClassCaretaker):
# Map attributes to 'class_default_for_' variables
def __getattr__(self,name):
return ClassCaretaker.__getattr__(self,'class_default_for_'+name)
def __setattr__(self,name,value):
ClassCaretaker.__setattr__(self,'class_default_for_'+name,value)
def __delattr__(self,name):
ClassCaretaker.__delattr__(self,'class_default_for_'+name)
class DataSkinSheet(ZCommonSheet):
"""Property sheet that creates class defaults for properties"""
meta_type="DataSkin Attribute Property Sheet"
def v_self(self):
klass=self.aq_inner.aq_parent.aq_parent.aq_parent._zclass_
return DefaultCaretaker(klass)
def SheetAttribute(name='',xmlns=''):
def getsheet(self,name=name,xmlns=xmlns):
return self.PropertySheet(name=name,xmlns=xmlns)
return ComputedAttribute(getsheet)
ZPatterns/DataSkins.py 0100644 0001752 0000627 00000033621 07543611361 014642 0 ustar roche upfront from DynPersist import DynPersist
from Globals import Persistent
from ComputedAttribute import ComputedAttribute
from Acquisition import ImplicitAcquisitionWrapper,aq_base
from DataManagers import DefaultDataManager
from PropertySheets import VirtualSheets, DataSkinSheet
from Globals import default__class_init__
from OFS.ObjectManager import ObjectManager
from OFS.CopySupport import CopySource
from AttributeProviders import NOT_FOUND
from ZClasses.Property import ZInstanceSheetsSheet
from ZClasses.ZClass import ZClassSheets
from Products.PlugIns import genericAddForm
from Transactions import Kept
_marker = []
_v_dm_ = '_v_dm_'
_v_status_ = '_v_status_'
ChangedStatus = 'Changed'
DeletedStatus = 'Deleted'
AddedStatus = 'Added'
manage_afterAdd = ObjectManager.manage_afterAdd.im_func
manage_beforeDelete = ObjectManager.manage_beforeDelete.im_func
manage_afterClone = ObjectManager.manage_afterClone.im_func
class Token:
status = memento = None
def __init__(self,client,agent):
self.agent = agent
self.client = client
if agent._isIndexingAgent:
get_transaction().registerIndex(self)
else:
get_transaction().registerRule(self)
def __call__(self):
self.agent(self)
class DataSkin(DynPersist,Persistent,Kept):
"""Mixin for objects that want to delegate storage issues externally"""
_rackMounted = 0
_isRackMountable = 1
def __init__(self, id=None):
# we could ditch this whole method except for backward compatibility :(
pass
def _setRack(self, rack):
"""Called by the rack before returning the object"""
d = self.__dict__
d[_v_dm_] = rack; d['_rackMounted'] = 1
# import zLOG; zLOG.LOG('MyDebugLog',0,'','setting rack (id: "%s") for %s (id: "%s"). d: "%s"'%(rack.id, self, self.id, d))
def _setSlot(self, slot):
"""
Set up the slot object for persistent storage of object
'baggage' (e.g. WebDAV property sheets, etc.). Called by
ZODB-based racks at object retrieval, or by non-ZODB based
racks at the object's request.
"""
self._v_readableSlot = self._v_writeableSlot = slot
def commitSubtransaction(self): return get_transaction().commit(1)
def _getTokenFor(self,agent):
"""Return a transaction state monitor for this DataSkin/agent combo"""
t,a = self._v_Tokens, id(agent.aq_base)
if not t.has_key(a): t[a]=Token(self,agent)
return t[a]
# Computed attributes to handle on-demand slot retrieval/allocation, etc.
__per_transaction_cache_attrs__ = (
'_v_currentSheets', '_v_attrCache', '_v_status_',
'_v_changedAttrs_', '_v_Tokens', '_v_dependencyMap'
)
def _getCache(self):
"""Return attribute cache"""
return self._v_attrCache
def _v_readableSlot(self,_v_dm_=_v_dm_):
return self.__dict__[_v_dm_]._readableSlotFor(self)
def _v_writeableSlot(self,_v_dm_=_v_dm_):
return self.__dict__[_v_dm_]._writeableSlotFor(self)
def _v_attrCache(self):
"""Cache of external attribute values"""
v = self._v_attrCache = {}; return v
def _v_Tokens(self):
"""Cache of agent transaction monitoring tokens"""
v = self._v_Tokens = {}; return v
_v_readableSlot = ComputedAttribute(_v_readableSlot)
_v_writeableSlot = ComputedAttribute(_v_writeableSlot)
_v_attrCache = ComputedAttribute(_v_attrCache)
_v_Tokens = ComputedAttribute(_v_Tokens)
# Event management (avoids sequential repeats of same events)
def _v_changedAttrs_(self):
"""Cache of changed attribute names"""
v = self._v_changedAttrs_ = {}
return v
_v_changedAttrs_ = ComputedAttribute(_v_changedAttrs_)
def _v_dependencyMap(self):
"""Map of attrs to be uncached if key attr changes"""
v = self._v_dependencyMap = {}
return v
_v_dependencyMap = ComputedAttribute(_v_dependencyMap)
def _setDependencies(self, attr, dependencies):
"""Make it so attr will be dropped from cache if
any of the attrs named in the dependencies list
are changed."""
m = self._v_dependencyMap
for dep in dependencies:
if m.has_key(dep): m[dep].append(attr)
else: m[dep]=[attr]
def _objectChanging(self,name,_v_status_=_v_status_,_v_dm_=_v_dm_):
d=self.__dict__
c=self._v_changedAttrs_
v=self._v_attrCache
if self._v_status_ is not ChangedStatus:
d[_v_dm_]._objectChanging(self)
d[_v_status_] = ChangedStatus
if not c.has_key(name):
c[name]=getattr(self,name,NOT_FOUND)
if d.has_key(name):
if name[:2] == '_v': import zLOG; zLOG.LOG('MyDebugLog',0,'','Hmm! Deleting %s from %s'%(name, d))
del d[name]; self._p_changed=1
if v.has_key(name): del v[name]
if self._v_dependencyMap:
for attr in self._v_dependencyMap.get(name, ()):
if v.has_key(attr):
del v[attr]
def _objectAdding(self,_v_status_=_v_status_,_v_dm_=_v_dm_):
if self._v_status_ is not AddedStatus:
d=self.__dict__
d[_v_dm_]._objectAdding(self)
d[_v_status_] = AddedStatus
def _objectCreating(self,_v_dm_=_v_dm_):
self.__dict__[_v_dm_]._objectCreating(self)
def _objectDeleting(self,_v_status_=_v_status_,_v_dm_=_v_dm_):
if self._v_status_ is not DeletedStatus:
d=self.__dict__
d[_v_dm_]._objectDeleting(self)
d[_v_status_] = DeletedStatus
# Attribute handling
def __get_attr__(self,name,_v_dm_=_v_dm_):
cache = self._v_attrCache
v = cache.get(name,_marker)
if v is _marker:
v = getattr(self.__class__,'class_default_for_'+name,NOT_FOUND)
cache[name] = v
# dm = self.__dict__[_v_dm_]
if self.__dict__.has_key(_v_dm_):
dm = self.__dict__[_v_dm_]
else:
import zLOG; zLOG.LOG('MyDebugLog',0,'','Eek! "_v_dm_" of %s (id: "%s") lost! self.__dict__: %s'%(self, self.id, self.__dict__))
self = self._canonicalForm()
for ap in dm._getProvidersFor(self,'getattr',(name,'*')):
v = ap._AttributeFor(self,name,NOT_FOUND)
if v is not NOT_FOUND:
cache[name]=v
return v
v = cache[name]
if v is not NOT_FOUND:
return v
raise AttributeError, name
def _canonicalForm(self):
self._v_Keeper # force existence of a keeper
if not self.__dict__.has_key('_v_parent'): import zLOG; zLOG.LOG('MyDebugLog',0,'','Eek! No `_v_parent` key on %s (id: "%s"), self.__dict__: %s'%(self, self.id, self.__dict__))
return ImplicitAcquisitionWrapper(
aq_base(self),
self.__dict__['_v_parent']
)
def __set_attr__(self,name,val,_v_dm_=_v_dm_):
d = self.__dict__
try:
dm = d[_v_dm_]
except KeyError:
# special case when name=='id'
if name=='id':
# optimisation for where id is already set appropriately
if d.has_key('id') and val==d['id']: return
else:
raise
if d.has_key('_v_parent'):
# Only try providers if we're bound to a canonical parent
self = self._canonicalForm()
self._objectChanging(name)
for ap in dm._getProvidersFor(self,'setattr',(name,'*')):
if ap._SetAttributeFor(self,name,val):
return
if not self._rackMounted or name in ('id','__name__'):
d[name]=val
self._p_changed = 1
return
# XXX default behavior for rackmounted?
raise AttributeError, name
def __del_attr__(self,name,_v_dm_=_v_dm_):
dm = self.__dict__[_v_dm_]
self = self._canonicalForm()
self._objectChanging(name)
for ap in dm._getProvidersFor(self,'delattr',(name,'*')):
if ap._DelAttributeFor(self,name):
return
if not self._rackMounted:
if self._v_changedAttrs_[name] is NOT_FOUND:
del self._v_changedAttrs_[name]
return
# XXX default behavior for rackmounted?
raise AttributeError, name
# DataManager hookup
_DefaultDataManager = DefaultDataManager()
def __of__(self,parent,
_iaw=ImplicitAcquisitionWrapper,_v_dm_=_v_dm_,type=type
):
# Bound to unwrapped parent, just try again
if type(parent) is not _iaw or not hasattr(parent,'REQUEST'):
return self
# Create our canonical form
new_self = _iaw(self,parent)
if type(self) is _iaw: # Been wrapped already?
return new_self # No special handling
self.__dict__['_v_parent'] = parent # save our canonical parent
# Rackmounted? just save/return canonical form
if self._rackMounted:
return new_self
# Otherwise, find our data manager
dm = self._DefaultDataManager
try: _gdmf = parent.aq_acquire('_getDataManagerFor')
except: pass
else: dm = _gdmf(new_self, dm)
self.__dict__[_v_dm_] = dm
return new_self
# ObjectManager Hooks to ensure event generation
def manage_afterAdd(self,item,container):
self._objectAdding()
if hasattr(self.aq_base,'objectValues'):
manage_afterAdd(self,item,container)
def manage_beforeDelete(self,item,container):
if hasattr(self.aq_base,'objectValues'):
manage_beforeDelete(self,item,container)
self._objectDeleting()
# Copy Support
def _getCopy(self, container):
self = aq_base(self).__of__(container)
ob = CopySource._getCopy.im_func(self,container)
ob.__of__(container) # force DM hookup
return ob
def manage_afterClone(self,item,_v_dm_=_v_dm_):
self = aq_base(self)
self = self._canonicalForm()
if hasattr(self.aq_base,'objectValues'):
manage_afterClone(self,item)
# Propertysheets
propertysheets = VirtualSheets()
def _addPropertySheet(self,name='',xmlns='',_v_dm_=_v_dm_):
"""
Return new propertysheet matching name or xmlns, if possible.
Otherwise return None.
"""
d=self.__dict__
if d.has_key('_v_currentSheets'):
del d['_v_currentSheets']
return self._delegateToSheetProviders(name,xmlns,'_addPropertySheetFor')
def _delPropertySheet(self,name='',xmlns='',_v_dm_=_v_dm_):
"""
Delete propertysheet matching name or xmlns, if present. Always
returns None (unless an unexpected error occurs, of course)
"""
d=self.__dict__
if d.has_key('_v_currentSheets'):
del d['_v_currentSheets']
return self._delegateToSheetProviders(name,xmlns,'_delPropertySheetFor')
def _delegateToSheetProviders(self,name,xmlns,mname):
dm = self.__dict__[_v_dm_]
self = self._canonicalForm()
if name:
for sp in dm._getProvidersFor(self,'sheet_names',(name,'*')):
s = getattr(sp,mname)(self, name=name, xmlns=xmlns)
if s is not None: return s
if xmlns:
for sp in dm._getProvidersFor(self,'sheet_xmlns',(xmlns,'*')):
s = getattr(sp,mname)(self, name=name, xmlns=xmlns)
if s is not None: return s
return None
def _v_currentSheets(self,_v_dm_=_v_dm_):
"""PropertySheets tuple (analagous to __propsets__)"""
l = []
for sp in self.__dict__[_v_dm_]._uniqueProviders(('sheets',)):
l.extend(list(sp._PropertySheetsFor(self)))
self._v_currentSheets = tuple(l)
return self._v_currentSheets
_v_currentSheets = ComputedAttribute(_v_currentSheets)
def manage_delete(self,_v_dm_=_v_dm_):
"""Delete this object"""
if self._rackMounted:
self.__dict__[_v_dm_]._objectDeleting(self)
return 'OK'
raise TypeError, "Not rack-mounted; please use container to delete"
meta_type = "Data Skin"
__ac_permissions__ = (
('Delete rack-mounted objects', ('manage_delete',)),
)
# DEPRECATED STUFF
def PropertySheets(self):
"""
Returns a 'propertysheets'-type object
DEPRECATED - use 'propertysheets' attribute instead.
"""
return self.propertysheets
def PropertySheet(self, name='', xmlns=''):
"""
Return a specific property sheet (DEPRECATED)
Doesn't work w/ZClass sheets! Use propertysheets.get() instead.
"""
return self._delegateToSheetProviders(name,xmlns,'_PropertySheetFor')
_v_status_ = ''
default__class_init__(DataSkin)
class SkinZISS(ZInstanceSheetsSheet):
manage_addDataSkinSheetForm = genericAddForm(DataSkinSheet)
def manage_addDataSkinSheet(self, id, title, REQUEST=None):
"""Add a DataSkin sheet"""
o=DataSkinSheet(id, title)
self._setObject(id, o)
if REQUEST is not None: return self.manage_main(self, REQUEST)
meta_types = (
{'name':DataSkinSheet.meta_type, 'action':'manage_addDataSkinSheetForm'},
) + ZInstanceSheetsSheet.meta_types
class SZHolder:
""" """
def __init__(self):
ZClassSheets.__init__.im_func(self)
self.common=SkinZISS('common')
class _ZClass_for_DataSkin:
propertysheets = SZHolder()
_zclass_ = DataSkin
manage_options = ()
def initialize(context):
context.registerZClass(_ZClass_for_DataSkin)
ZPatterns/Proxy.py 0100644 0001752 0000627 00000002623 07543611361 014100 0 ustar roche upfront from Globals import DTMLFile
from AccessControl import getSecurityManager
class ProxyManager:
"""Manage proxy role settings"""
_proxy_roles=()
manage_options=(
{'label':'Proxy', 'action':'manage_proxyForm',
'help':('OFSP','DTML-DocumentOrMethod_Proxy.stx')},
)
__ac_permissions__=(
('Change proxy roles', ('manage_proxyForm', 'manage_proxy')),
)
manage_proxyForm=DTMLFile('documentProxy', globals())
def manage_haveProxy(self,r): return r in self._proxy_roles
def _validateProxy(self, request, roles=None):
if roles is None: roles=self._proxy_roles
if not roles: return
user=u=getSecurityManager().getUser()
user=user.hasRole
for r in roles:
if r and not user(self, (r,)):
user=None
break
if user is not None: return
raise 'Forbidden', (
'You are not authorized to change %s because you '
'do not have proxy roles.\n' % (self.__name__, u, roles))
def manage_proxy(self, roles=(), REQUEST=None):
"Change Proxy Roles"
self._validateProxy(REQUEST, roles)
self._validateProxy(REQUEST)
self._proxy_roles=tuple(roles)
if REQUEST:
return self.manage_proxyForm(self, REQUEST,
manage_tabs_message='Saved changes.')
ZPatterns/Providers.py 0100644 0001752 0000627 00000017352 07543611361 014741 0 ustar roche upfront from Products.PlugIns import PlugIn, PlugInGroup, defaultConstructors
from Globals import DTMLFile, default__class_init__
from OFS.PropertyManager import PropertyManager
class NullProvider:
def _objectAdding(self,client): pass
def _objectCreating(self,client): pass
def _objectChanging(self,client): pass
def _objectDeleting(self,client): pass
def _getProviders(self): return self,
class Provider(PlugIn, NullProvider, PropertyManager):
"""Simple properties-based interface for attribute and sheet providers"""
manage_options = (
{'label':'Properties', 'action':'manage_propertiesForm'},
)
def manage_editProperties(self, REQUEST):
"""Edit object properties via the web."""
r = PropertyManager.manage_editProperties(self,REQUEST)
self._propertiesChanged()
self.aq_inner.aq_parent.manage_refreshPlugIns()
return r
def manage_changeProperties(self, REQUEST=None, **kw):
"""Change existing object properties."""
r = apply(PropertyManager.manage_changeProperties,(self,REQUEST),kw)
self._propertiesChanged()
self.aq_inner.aq_parent.manage_refreshPlugIns()
return r
def manage_addProperty(self, id, value, type, REQUEST=None):
"""Add a new property via the web. Sets a new property with
the given id, type, and value."""
r = PropertyManager.manage_addProperty(self,id,value,type,REQUEST)
self._propertiesChanged()
self.aq_inner.aq_parent.manage_refreshPlugIns()
return r
def manage_delProperties(self, ids=None, REQUEST=None):
"""Delete one or more properties specified by 'ids'."""
r = PropertyManager.manage_delProperties(self,ids,REQUEST)
self._propertiesChanged()
self.aq_inner.aq_parent.manage_refreshPlugIns()
return r
def _propertiesChanged(self): pass
def propertyLabel(self,id):
return self.propertyLabels.get(id,id)
propertyLabels={}
default__class_init__(Provider)
class ProviderGroup(PlugInGroup):
"""
PlugInGroup that manages the more complex registration needs
of Attribute/Sheet/etc. Providers
"""
def _PlugInsChanged(self, container, plugins=()):
"""Update the registry of names"""
r = container.__provider_registry__ = {}
l = container.__allProviders__ = []
for bp in plugins:
for plugin in bp.__of__(container)._getProviders():
l.append(plugin)
nametable = plugin.namesForRegistration(container)
for namekind, names in nametable.items():
d = r.get(namekind,{})
for n in names:
if d.has_key(n):
d[n].append(plugin)
else:
d[n]=[plugin]
r[namekind] = d
manage_below = DTMLFile('www/showDiagnostics', globals())
def manage_registry(self,name):
return self.aq_parent._getRegistry(name)
def manage_attrMap(self):
g=self.manage_registry('getattr')
s=self.manage_registry('setattr')
d=self.manage_registry('delattr')
m={}; m.update(g); m.update(s); m.update(d)
for k in m.keys():
v = m[k] = {'rd':[],'wr':[], 'del':[]}
if g.has_key(k): v['rd']=g[k]
if s.has_key(k): v['wr']=s[k]
if d.has_key(k): v['del']=s[k]
return m.items()
__ac_permissions__ = (
('View management screens',
('manage_registry','manage_attrMap','manage_below')
),
)
default__class_init__(ProviderGroup)
class ProviderContainer:
__provider_registry__ = {}
__dataProviders__ = ()
__allProviders__ = ()
DataPlugins = ProviderGroup(
'DataPlugins',
['Property Sheet Provider','Attribute Provider', 'Monitoring Agent',
'Data Plug-in'],
title = 'Data Plug-ins',
attr = '__dataProviders__'
)
__plugin_groups__ = (DataPlugins,)
def _getRegistry(self,name):
return self.__provider_registry__.get(name,{})
def _uniqueProviders(self,kinds):
d = {}; have = d.has_key
l = []
providers = self._getRegistry('provides')
for kind in kinds:
for pp in providers.get(kind,()):
if have(id(pp)): continue
l.append(pp.__of__(self)); d[id(pp)]=1
return l
def _getProvidersFor(self,client,kind,names):
r = self._getRegistry(kind); l=[]
for n in names:
for p in r.get(n,()):
l.append(p.__of__(self))
return l
def __setstate__(self,state):
"""Upgrade data structures from pre 0.4.0 versions"""
d = self.__dict__; d.clear()
if state.has_key('__provider_registry__'):
if not state.has_key('__allProviders__') and \
state.has_key('__dataProviders__'):
state['__allProviders__']=state['__dataProviders__']
d.update(state)
return
p = {}
l = state['__dataProviders__'] = state['__allProviders__'] = []
r = state['__provider_registry__'] = {'provides':p}
for new,old in (
('sheets', '__sheetProviders__'),
('attributes','__attributeProviders__'),
('handlers','__indexAgents__'),
('handlers','__triggerAgents__'),
):
if state.has_key(old):
p[new] = state[old]; l.extend(state[old])
del state[old]
for new,old in (
('getattr', '__getattr_registry__'),
('setattr', '__setattr_registry__'),
('sheet_names', '__sheet_registry__'),
('sheet_xmlns', '__xmlns_registry__'),
):
if state.has_key(old):
r[new] = state[old]
del state[old]
for ap in 'getattr','setattr':
if r.has_key(ap):
z = r[ap]
for k,v in z.items(): z[k] = [v] # new registry expects provider list
if r.has_key('setattr'): r['delattr'] = r['setattr'].copy()
d.update(state)
class LinkToParentProviders(Provider):
"""Provide attributes, etc. from an acquired provider"""
meta_type='Link to parent Data Plug-ins'
__plugin_kind__ = 'Data Plug-in'
excludePIs=()
def _getProviders(self):
r=getattr(self.aq_inner.aq_parent.aq_parent,'__allProviders__',())
return filter(lambda x,exclude=tuple(self.excludePIs): x.id not in exclude, r)
def parentPIids(self):
r=getattr(self.aq_inner.aq_parent.aq_parent,'__allProviders__',())
return map(lambda x:x.id, r)
_properties=(
{'id':'title', 'type': 'string', 'mode': 'w'},
{'id':'excludePIs', 'type': 'multiple selection',
'mode': 'w', 'select_variable':'parentPIids'},
)
propertyLabels={'excludePIs':'Use all parent plug-ins EXCEPT'}
def _propertiesChanged(self):
# get rid of old (pre 0.4.2) properties
d = self.__dict__
for k in 'Attributes','Sheet_Names','Sheet_Namespaces':
if d.has_key(k): del d[k]
default__class_init__(LinkToParentProviders)
def initialize(context):
context.registerPlugInClass(
LinkToParentProviders,
permission = 'Add Links to Parent Data Plug-ins',
constructors = defaultConstructors(LinkToParentProviders,globals()),
icon = 'www/acqattrprov.gif'
)
ZPatterns/README.txt 0100644 0001752 0000627 00000011076 07543611361 014105 0 ustar roche upfront A Database Independence and Framework Integration Pattern Language for Zope
Copyright
Copyright 2000, 2001 Phillip J. Eby and Tyler Sarna - All Rights Reserved.
This software may be used, modified, and distributed, under the same
terms as Zope itself.
Upgrade Notice
If you are upgrading from an earlier release of ZPatterns, please read the
"CHANGES.txt":Help/CHANGES.txt file for important information
about updating.
ZPatterns Introduction
The ZPatterns product provides a variety of base classes and frameworks
for Zope product and application development. Some currently available
components include:
DataSkins (New in 0.4.0) -- A way to use the features of RackMountables
(pluggable data and event handling) with objects stored in regular ZODB
containers. DataSkins just need to be under a "folder w/customization
support" that contains Customizer objects.
PlugIns -- A framework for Folder-like objects ("plugin containers") to have
management tabs ("plugin groups") that hold collections of objects
("plugins") supporting a particular collaboration interface ("plugin kind")
SheetProviders -- A framework for providing database-independent property
sheets to objects. SheetProviders are PlugIns which Racks and Specialists
use to give their contents PropertySheets, without any objects (besides the
SheetProviders) needing to know how the property sheets are implemented or
where they are stored. One can create SheetProviders that store data in
literally any kind of database accessible by Zope.
AttributeProviders (New in 0.3.0) -- Similar to SheetProviders, but for
individual object attributes.
Racks -- A framework for database-independent collections of objects. Racks
retrieve or store objects. They are SheetProviderContainers and
AttributeProviderContainers, and thus allow for property sheets and
attributes to be added to their contents from another database. The default
Rack implementation stores all data in the ZODB (as do the default
"provider" implementations), but the framework code is documented for easy
subclassing to create alternative storage methods.
Specialists (New in 0.3.0) -- A way of organizing your applications around
object interfaces and class-level services. (Known as 'Implementors' in
the original RIPP Model)
Currently, these patterns are used by the
"LoginManager product":http://www.zope.org/Members/tsarna/LoginManager
which uses Rack as a base for UserSources, PlugIn as a base for LoginMethods,
and Specialist as a base for LoginManager itself. Thus, by creating
Attribute or Sheet Provider objects, you can extend LoginManager's
capabilities, as well as the capabilities of any other systems built on
Racks and Specialists.
Installation/Setup
To support AttributeProviders and other useful features, ZPatterns
includes a C extension which must be built before the product can be used.
After unpacking the ZPatterns product, you will need to build this extension
using the included 'Setup' file in the ZPatterns directory. If you are not
building ZPatterns in the lib/python/Products directory of your Zope
installation, you will need to edit the 'Setup' file to reflect the correct
paths to the include files it wants. Please follow the standard procedures
for building a Python module on your platform. (On Unix-ish systems, this
usually consists of copying a 'Makefile.pre.in' to the directory, then doing a
'make -f Makefile.pre.in boot' followed by 'make'.
Once the extension is built, restart Zope to install the product. Then, if
you are upgrading from a previous version of ZPatterns, follow the upgrade
procedures in the "CHANGES.txt":Help/CHANGES.txt file to update classes and
instances of objects based on the previous version of ZPatterns.
Where to Find Other Documentation
You can now use the Zope built-in help system to read LoginManager and
ZPatterns documentation, or see the Products/ZPatterns/help
directory. At present, only these files exist:
"TODO.txt":Help/TODO.txt -- Bugs, future features, etc.
"CHANGES.txt":Help/CHANGES.txt -- Changes since previous releases,
upgrade notes
Please also see the "ZPatterns Wiki":http://www.zope.org/Members/pje/Wikis/ZPatterns/
Also, the ZPatterns are based on the RIPP pattern model presented by Phillip
Eby at the Zope Track of IPC-8. There is a "PowerPoint presentation of that
talk":http://www.zope.org/Members/pje/RIPP_Model.ppt available. (Also
available in "HTML format":http://www.zope.org/Members/pje/RIPP_Talk_HTML )
ZPatterns/DynPersist.c 0100644 0001752 0000627 00000006366 07543611361 014665 0 ustar roche upfront #include "cPersistence.h"
#define cPersistenceImported \
(cPersistenceCAPI=PyCObject_Import("cPersistence","CAPI"))
#define Per_getattr (cPersistenceCAPI->pergetattro)
#define Per_setattr (cPersistenceCAPI->persetattro)
#define ASSIGN(V,E) {PyObject *__e; __e=(E); Py_XDECREF(V); (V)=__e;}
#define UNLESS(E) if(!(E))
static PyObject *__get_attr__, *__set_attr__, *__del_attr__;
static struct PyMethodDef dpMethods[] = { {NULL,NULL} };
static PyObject*
getattro_hook(PyObject *self, PyObject *name) {
PyObject *r, *v, *tb;
if (r = Py_FindAttr(self,name)) return r; /* Found it first try */
PyErr_Fetch(&r,&v,&tb);
if (r && (r != PyExc_AttributeError)) {
PyErr_Restore(r,v,tb);
return NULL;
}
Py_XDECREF(r); Py_XDECREF(v); v=NULL; Py_XDECREF(tb);
PyErr_Clear();
if ((r = Py_FindAttr(self,__get_attr__)) && (v = PyTuple_New(1))) {
PyTuple_SET_ITEM(v, 0, name);
ASSIGN(r,PyObject_CallObject(r,v));
PyTuple_SET_ITEM(v, 0, NULL);
Py_DECREF(v);
if (r && has__of__(r)) ASSIGN(r,PyObject_CallMethod(r,"__of__","O",self))
return r;
} else { Py_XDECREF(r); return NULL; }
}
static PyObject*
p_getattro(cPersistentObject *self, PyObject *name)
{
char *s=NULL;
if (PyString_Check(name))
UNLESS(s=PyString_AsString(name)) return NULL;
return Per_getattr((PyObject *)self, name, s, getattro_hook);
}
static int
p_setattro(cPersistentObject *self, PyObject *oname, PyObject *val)
{
char *name; PyObject *r, *t;
UNLESS(oname) return -1;
if(PyString_Check(oname))
UNLESS(name=PyString_AsString(oname)) return -1;
if(*name=='_' && (name[1]=='p' || name[1]=='v')&& name[2]=='_')
return Per_setattr((PyObject *)self,oname, val,
PyExtensionClassCAPI->setattro);
if (!val) {
if ((r = Py_FindAttr((PyObject *)self,__del_attr__))
&& (t = PyTuple_New(1)))
{
PyTuple_SET_ITEM(t, 0, oname);
ASSIGN(r,PyObject_CallObject(r,t));
PyTuple_SET_ITEM(t, 0, NULL);
Py_DECREF(t);
if (r) { Py_DECREF(r); return 0; }
}
}
else if ((r = Py_FindAttr((PyObject *)self,__set_attr__))
&& (t = PyTuple_New(2)))
{
PyTuple_SET_ITEM(t, 0, oname);
PyTuple_SET_ITEM(t, 1, val);
ASSIGN(r,PyObject_CallObject(r,t));
PyTuple_SET_ITEM(t, 0, NULL);
PyTuple_SET_ITEM(t, 1, NULL);
Py_DECREF(t);
if (r) { Py_DECREF(r); return 0; }
}
Py_XDECREF(r); return -1;
}
void
initDynPersist()
{
PyObject *m, *d;
PURE_MIXIN_CLASS(DynPersist,
"cPersistence.Persistent subclass supporting __getattr__",
dpMethods);
DynPersistType.tp_getattro = (getattrofunc) p_getattro;
DynPersistType.tp_setattro = (setattrofunc) p_setattro;
UNLESS(ExtensionClassImported) return;
UNLESS(cPersistenceImported) return;
/* Make up a type */
m = Py_InitModule4(
"DynPersist",
dpMethods, /* hack, use it since it's empty... */
"Persistent's with __getattr__!",
(PyObject*)NULL,
PYTHON_API_VERSION
);
__get_attr__ = PyString_InternFromString("__get_attr__");
__set_attr__ = PyString_InternFromString("__set_attr__");
__del_attr__ = PyString_InternFromString("__del_attr__");
d = PyModule_GetDict(m);
PyDict_SetItemString(d,"__version__", PyString_FromString("0.2"));
PyExtensionClass_Export(d,"DynPersist",DynPersistType);
if (PyErr_Occurred())
Py_FatalError("can't initialize module PersistWithGetattr");
}
ZPatterns/Agents.py 0100644 0001752 0000627 00000015021 07543611361 014174 0 ustar roche upfront from Proxy import ProxyManager
from Providers import Provider
from ComputedAttribute import ComputedAttribute
from DataSkins import AddedStatus, ChangedStatus, DeletedStatus, NOT_FOUND
# XXX from zLOG import LOG, INFO, ERROR
from Products.PlugIns import defaultConstructors
from Expressions import *
from string import split,strip
class AgentMixin:
_isIndexingAgent=0
def namesForRegistration(self,container):
"Agents provide 'handlers'; subclasses may add attributes and sheets"
return { 'provides': ('handlers',) }
def _objectAdding(self, client,
_tmap={ None:AddedStatus,
DeletedStatus:ChangedStatus,
ChangedStatus:AddedStatus
}
):
t = client._getTokenFor(self)
s = t.status
t.status = _tmap.get(s,s)
def _objectDeleting(self,client):
t = client._getTokenFor(self)
s = t.status
if s is None:
t.status = DeletedStatus
t.memento = self._getMementoFor(client)
elif s is AddedStatus:
t.status = None
elif s is ChangedStatus:
t.status = DeletedStatus
def _objectChanging(self,client):
t = client._getTokenFor(self)
if t.status is None:
t.status = ChangedStatus
t.memento = self._getMementoFor(client)
def __call__(self, token):
s, c = token.status, token.client
if s is ChangedStatus:
self._objectChanged(c, token.memento)
elif s is AddedStatus:
self._objectAdded(c)
elif s is DeletedStatus:
self._objectDeleted(c, token.memento)
class Agent(AgentMixin, Provider):
"""Thing that monitors DataSkin events"""
__plugin_kind__ = 'Monitoring Agent'
def _getMementoFor(self,client):
# Override to return a memento object relevant to the agent
pass
def _objectChanged(self,client,memento):
pass
def _objectDeleted(self,client,memento):
pass
def _objectAdded(self,client):
pass
class GTMixin:
def _getMementoFor(self,client):
if not self._mementos:
return _emptyMemento
memento = _memento()
d=memento.__dict__
t = NamespaceStack()
t._push(InstanceDict(client, t))
pushProxy(self)
try:
for n,e in self._mementos:
d[n] = e.eval(t)
finally:
popProxy(self)
t._pop()
return memento
def _objectChanged(self,client,memento):
self._notify('CHANGE',client,memento)
def _objectDeleted(self,client,memento):
self._notify('DELETE',client,memento)
def _objectAdded(self,client):
self._notify('ADD',client,_emptyMemento)
def namesForRegistration(self,container):
if self.handle_set_for:
return {
'provides': ('handlers','attributes'),
'setattr': self.handle_set_for,
'delattr': self.handle_set_for,
}
return { 'provides': ('handlers',) }
_onlySaveAttrs = 0
def _notify(self,event,client,memento):
if event not in self.applicable_events or self._expr is None:
return
changed = client._v_changedAttrs_
CHANGED = changed.has_key
if self._onlySaveAttrs and not ('*' in self.handle_set_for and changed):
# Don't call unless one of the attrs is changed
for a in self.handle_set_for:
if CHANGED(a): break
else:
return
#LOG('ZPatterns', INFO, 'Object %s from [%s] to [%s]' %
# (event,memento.__dict__,self._getMementoFor(client).__dict__)
#) XXX
t = NamespaceStack()
t._push(InstanceDict(self, t))
t._push({
'self':client, 'TRIGGER_EVENT':event, 'OLD':memento,
'CHANGED': CHANGED, 'HAS_CHANGED': CHANGED,
'CHANGED_ATTRS': changed.keys,
'ORIGINAL': changed.copy(), 'NOT_FOUND': NOT_FOUND,
})
pushProxy(self)
try:
result = self._expr.eval(t)
finally:
popProxy(self)
t._pop(2)
return result
def _SetAttributeFor(self,client,name,value):
client._getCache()[name]=value
return 1
def _DelAttributeFor(self,client,name):
"""Delete the attribute and return true if successful"""
client._getCache()[name]=NOT_FOUND
if client._v_changedAttrs_[name] is NOT_FOUND: del client._v_changedAttrs_[name]
return 1
class GenericTrigger(GTMixin,Agent,ProxyManager):
"""Call an expression upon change to an object"""
meta_type = 'Generic Trigger'
manage_options = Agent.manage_options + ProxyManager.manage_options
_mementos = memento_exprs = handle_set_for = ()
_expr = None
callexpr = ''
applicable_events = event_kinds = 'ADD', 'CHANGE', 'DELETE'
def _propertiesChanged(self):
m = self._mementos = []
if self.callexpr: self._expr = Expression(self.callexpr)
else: self._expr = None
for l in self.memento_exprs:
if strip(l):
if '=' in l:
a,e = split(strip(l), '=', 1)
m.append(a,Expression(e))
else:
m.append(l,Name(l))
_properties=(
{'id':'title', 'type': 'string', 'mode': 'w'},
{'id':'applicable_events', 'type': 'multiple selection',
'mode': 'w', 'select_variable':'event_kinds'},
{'id':'callexpr', 'type': 'string', 'mode': 'w'},
{'id':'memento_exprs', 'type': 'lines', 'mode': 'w'},
{'id':'handle_set_for','type': 'lines', 'mode': 'w'},
)
propertyLabels = {
'title':'Title',
'applicable_events': 'Upon:',
'callexpr':'Execute:',
'memento_exprs': 'Keeping:', 'handle_set_for':'Set Attrs:'
}
class _memento:
__allow_access_to_unprotected_subobjects__ = 1
def __getitem__(self, name):
return self.__dict__[name]
_emptyMemento=_memento()
def initialize(context):
return
# disabled
context.registerPlugInClass(
GenericTrigger,
permission = 'Add Generic Triggers',
constructors = defaultConstructors(GenericTrigger,globals()),
icon = 'www/trigger.gif'
)
ZPatterns/__init__.py 0100644 0001752 0000627 00000001525 07543611361 014516 0 ustar roche upfront import Rack, Specialists, Customizers, AttributeProviders, SheetProviders
import DataSkins, Agents, Providers, SkinScript
from zLOG import register_subsystem
register_subsystem('ZPatterns')
def initialize(context):
for m in (
Rack, Specialists, Customizers, DataSkins,
Providers, AttributeProviders, SheetProviders, Agents, SkinScript
):
m.initialize(context)
if hasattr(context,'registerHelp'):
context.registerHelp()
# The only way to register extra permissions for a ZClass base at present
# Waaaa
__ac_permissions__ = (
('Delete rack-mounted objects', ()),
)
# Backward compatibility needed due to the way registerBaseClass makes
# ZClass meta-classes...
from DataSkins import _ZClass_for_DataSkin
_ZClass_for_RackMountable = _ZClass_for_DataSkin # pre 0.4.0 compatibility
ZPatterns/addSpecialist.dtml 0100644 0001752 0000627 00000002051 07543611361 016033 0 ustar roche upfront
ZPatterns/ZED_PATTERNS_RELEASE_NOTES.txt 0100644 0001752 0000627 00000005641 07543611361 017223 0 ustar roche upfront 28 December 2001
Welcome to ZedPatterns-0-4-3p2-transactionagents-005
Changes:
* Changed TransactionAgents/tests/test_transactions.py to use
self.assertEqual(x,y) rather than assert x==y, since it
apparently gives much better output.
* In ZPatterns.Expressions.NamespaceStack, added a None default
value to the md argument of the verify method.
This is needed so that ZPatterns works with Zope 2.5.
* SkinScript methods can be edited via FTP. Thanks to
Roch Compaan for the patch.
23 September 2001
Welcome to ZedPatterns-0-4-3p2-transactionagents-004
Changes:
* Fixed bug in ZPatterns/DataSkins.py that wrongly assumed the
existence of 'id' in the instance __dict__. This stopped
DataSkins + Folder w/ Customizer Support working properly.
Welcome to ZedPatterns-0-4-3p2-transactionagents-003
Changes:
* Removed ArmTriggers method from ZPatterns/DataSkins.py
* Added DynPersist.pyd as contributed by Steve Spicklemire, compiled
for Zope 2.4 on Python2.1 on Win32
* Added Steve Spicklemire's fix to PlugIns to get rid of the ambiguous
method names
* BoundaryAgents now run on subtransaction commits as well as outer
transaction commits. Fixed tests to reflect this.
31 July 2001
Welcome to ZedPatterns-0-4-3p2-transactionagents-002
Changes:
* Added PrincipiaSearchSource method to SkinScript/Methods.py to
make SkinScript Methods work with ZopeFind.
* Fixed bug in INDEX CALLING syntax in SkinScript.
You'll need to recompile any SkinScript that uses this syntax,
by editing it in the ZMI.
26 July 2001
Welcome to ZedPatterns-0-4-3p2-transactionagents.
This is an experimental and unofficial release of ZPatterns,
to test out new ideas, and clear a path to compatibility with
Zope 2.4 and Python 2.1.
I've included an unaltered copy of the PlugIns product, as it
is required by ZPatterns.
UnTar the contents of the archive directly in your Products
directory.
Changes from ZPatterns 0-4-3p2:
* SkinScript works with Zope 2.4.
* Fixed __set_attr__ bug involving _v_parent
* Requires Python 2.1, Zope 2.4.
* Requires TransactionAgents product.
* Agents now run just before transactions get commited
rather than during a tpc_commit.
* New SkinScript for running a trigger as an IndexingAgent.
It goes like this::
WHEN OBJECT CHANGED INDEX CALLING expression
Indexing agents run after normal agents/triggers (called
Rule Agents), although there are special rules for
when a subtransaction is committed while an agent is running.
See the TransactionAgents product's test suite for details.
* ZPatterns doesn't go into an infinite loop if you commit
a subtransaction from a trigger.
* Support for list comprehensions in SkinScript.
* Per-transaction cached _v_ attributes now last until the
outermost transaction has finished. This will improve
execution speed by a miniscule amount in some circumstances.
--
Steve Alexander
Software Engineer
Cat-Box limited
ZPatterns/PlugIns.py 0100644 0001752 0000627 00000000255 07543611361 014337 0 ustar roche upfront """Backward compatibility for code that still expects PlugIns to be in ZPatterns
"""
from Products.PlugIns import *
# get rid of package-level init method
del initialize
ZPatterns/DataSkins.py.orig 0100644 0001752 0000627 00000032071 07543611361 015577 0 ustar roche upfront from DynPersist import DynPersist
from Globals import Persistent
from ComputedAttribute import ComputedAttribute
from Acquisition import ImplicitAcquisitionWrapper,aq_base
from DataManagers import DefaultDataManager
from PropertySheets import VirtualSheets, DataSkinSheet
from Globals import default__class_init__
from OFS.ObjectManager import ObjectManager
from OFS.CopySupport import CopySource
from AttributeProviders import NOT_FOUND
from ZClasses.Property import ZInstanceSheetsSheet
from ZClasses.ZClass import ZClassSheets
from Products.PlugIns import genericAddForm
from Transactions import Kept
_marker = []
_v_dm_ = '_v_dm_'
_v_status_ = '_v_status_'
ChangedStatus = 'Changed'
DeletedStatus = 'Deleted'
AddedStatus = 'Added'
manage_afterAdd = ObjectManager.manage_afterAdd.im_func
manage_beforeDelete = ObjectManager.manage_beforeDelete.im_func
manage_afterClone = ObjectManager.manage_afterClone.im_func
class Token:
status = memento = None
def __init__(self,client,agent):
self.agent = agent
self.client = client
if agent._isIndexingAgent:
get_transaction().registerIndex(self)
else:
get_transaction().registerRule(self)
def __call__(self):
self.agent(self)
class DataSkin(DynPersist,Persistent,Kept):
"""Mixin for objects that want to delegate storage issues externally"""
_rackMounted = 0
_isRackMountable = 1
def __init__(self, id=None):
# we could ditch this whole method except for backward compatibility :(
pass
def _setRack(self, rack):
"""Called by the rack before returning the object"""
d = self.__dict__
d[_v_dm_] = rack; d['_rackMounted'] = 1
def _setSlot(self, slot):
"""
Set up the slot object for persistent storage of object
'baggage' (e.g. WebDAV property sheets, etc.). Called by
ZODB-based racks at object retrieval, or by non-ZODB based
racks at the object's request.
"""
self._v_readableSlot = self._v_writeableSlot = slot
def commitSubtransaction(self): return get_transaction().commit(1)
def _getTokenFor(self,agent):
"""Return a transaction state monitor for this DataSkin/agent combo"""
t,a = self._v_Tokens, id(agent.aq_base)
if not t.has_key(a): t[a]=Token(self,agent)
return t[a]
# Computed attributes to handle on-demand slot retrieval/allocation, etc.
__per_transaction_cache_attrs__ = (
'_v_currentSheets', '_v_attrCache', '_v_status_',
'_v_changedAttrs_', '_v_Tokens', '_v_dependencyMap'
)
def _getCache(self):
"""Return attribute cache"""
return self._v_attrCache
def _v_readableSlot(self,_v_dm_=_v_dm_):
return self.__dict__[_v_dm_]._readableSlotFor(self)
def _v_writeableSlot(self,_v_dm_=_v_dm_):
return self.__dict__[_v_dm_]._writeableSlotFor(self)
def _v_attrCache(self):
"""Cache of external attribute values"""
v = self._v_attrCache = {}; return v
def _v_Tokens(self):
"""Cache of agent transaction monitoring tokens"""
v = self._v_Tokens = {}; return v
_v_readableSlot = ComputedAttribute(_v_readableSlot)
_v_writeableSlot = ComputedAttribute(_v_writeableSlot)
_v_attrCache = ComputedAttribute(_v_attrCache)
_v_Tokens = ComputedAttribute(_v_Tokens)
# Event management (avoids sequential repeats of same events)
def _v_changedAttrs_(self):
"""Cache of changed attribute names"""
v = self._v_changedAttrs_ = {}
return v
_v_changedAttrs_ = ComputedAttribute(_v_changedAttrs_)
def _v_dependencyMap(self):
"""Map of attrs to be uncached if key attr changes"""
v = self._v_dependencyMap = {}
return v
_v_dependencyMap = ComputedAttribute(_v_dependencyMap)
def _setDependencies(self, attr, dependencies):
"""Make it so attr will be dropped from cache if
any of the attrs named in the dependencies list
are changed."""
m = self._v_dependencyMap
for dep in dependencies:
if m.has_key(dep): m[dep].append(attr)
else: m[dep]=[attr]
def _objectChanging(self,name,_v_status_=_v_status_,_v_dm_=_v_dm_):
d=self.__dict__
c=self._v_changedAttrs_
v=self._v_attrCache
if self._v_status_ is not ChangedStatus:
d[_v_dm_]._objectChanging(self)
d[_v_status_] = ChangedStatus
if not c.has_key(name):
c[name]=getattr(self,name,NOT_FOUND)
if d.has_key(name):
del d[name]; self._p_changed=1
if v.has_key(name): del v[name]
if self._v_dependencyMap:
for attr in self._v_dependencyMap.get(name, ()):
if v.has_key(attr):
del v[attr]
def _objectAdding(self,_v_status_=_v_status_,_v_dm_=_v_dm_):
if self._v_status_ is not AddedStatus:
d=self.__dict__
d[_v_dm_]._objectAdding(self)
d[_v_status_] = AddedStatus
def _objectCreating(self,_v_dm_=_v_dm_):
self.__dict__[_v_dm_]._objectCreating(self)
def _objectDeleting(self,_v_status_=_v_status_,_v_dm_=_v_dm_):
if self._v_status_ is not DeletedStatus:
d=self.__dict__
d[_v_dm_]._objectDeleting(self)
d[_v_status_] = DeletedStatus
# Attribute handling
def __get_attr__(self,name,_v_dm_=_v_dm_):
cache = self._v_attrCache
v = cache.get(name,_marker)
if v is _marker:
v = getattr(self.__class__,'class_default_for_'+name,NOT_FOUND)
cache[name] = v
dm = self.__dict__[_v_dm_]
self = self._canonicalForm()
for ap in dm._getProvidersFor(self,'getattr',(name,'*')):
v = ap._AttributeFor(self,name,NOT_FOUND)
if v is not NOT_FOUND:
cache[name]=v
return v
v = cache[name]
if v is not NOT_FOUND:
return v
raise AttributeError, name
def _canonicalForm(self):
self._v_Keeper # force existence of a keeper
return ImplicitAcquisitionWrapper(
aq_base(self),
self.__dict__['_v_parent']
)
def __set_attr__(self,name,val,_v_dm_=_v_dm_):
d = self.__dict__
try:
dm = d[_v_dm_]
except KeyError:
if name=='id' and val==d['id']: return
raise
if d.has_key('_v_parent'):
# Only try providers if we're bound to a canonical parent
self = self._canonicalForm()
self._objectChanging(name)
for ap in dm._getProvidersFor(self,'setattr',(name,'*')):
if ap._SetAttributeFor(self,name,val):
return
if not self._rackMounted or name in ('id','__name__'):
d[name]=val
self._p_changed = 1
return
# XXX default behavior for rackmounted?
raise AttributeError, name
def __del_attr__(self,name,_v_dm_=_v_dm_):
dm = self.__dict__[_v_dm_]
self = self._canonicalForm()
self._objectChanging(name)
for ap in dm._getProvidersFor(self,'delattr',(name,'*')):
if ap._DelAttributeFor(self,name):
return
if not self._rackMounted:
if self._v_changedAttrs_[name] is NOT_FOUND:
del self._v_changedAttrs_[name]
return
# XXX default behavior for rackmounted?
raise AttributeError, name
# DataManager hookup
_DefaultDataManager = DefaultDataManager()
def __of__(self,parent,
_iaw=ImplicitAcquisitionWrapper,_v_dm_=_v_dm_,type=type
):
# Bound to unwrapped parent, just try again
if type(parent) is not _iaw or not hasattr(parent,'REQUEST'):
return self
# Create our canonical form
new_self = _iaw(self,parent)
if type(self) is _iaw: # Been wrapped already?
return new_self # No special handling
self.__dict__['_v_parent'] = parent # save our canonical parent
# Rackmounted? just save/return canonical form
if self._rackMounted:
return new_self
# Otherwise, find our data manager
dm = self._DefaultDataManager
try: _gdmf = parent.aq_acquire('_getDataManagerFor')
except: pass
else: dm = _gdmf(new_self, dm)
self.__dict__[_v_dm_] = dm
return new_self
# ObjectManager Hooks to ensure event generation
def manage_afterAdd(self,item,container):
self._objectAdding()
if hasattr(self.aq_base,'objectValues'):
manage_afterAdd(self,item,container)
def manage_beforeDelete(self,item,container):
if hasattr(self.aq_base,'objectValues'):
manage_beforeDelete(self,item,container)
self._objectDeleting()
# Copy Support
def _getCopy(self, container):
self = aq_base(self).__of__(container)
ob = CopySource._getCopy.im_func(self,container)
ob.__of__(container) # force DM hookup
return ob
def manage_afterClone(self,item,_v_dm_=_v_dm_):
self = aq_base(self)
self = self._canonicalForm()
if hasattr(self.aq_base,'objectValues'):
manage_afterClone(self,item)
# Propertysheets
propertysheets = VirtualSheets()
def _addPropertySheet(self,name='',xmlns='',_v_dm_=_v_dm_):
"""
Return new propertysheet matching name or xmlns, if possible.
Otherwise return None.
"""
d=self.__dict__
if d.has_key('_v_currentSheets'):
del d['_v_currentSheets']
return self._delegateToSheetProviders(name,xmlns,'_addPropertySheetFor')
def _delPropertySheet(self,name='',xmlns='',_v_dm_=_v_dm_):
"""
Delete propertysheet matching name or xmlns, if present. Always
returns None (unless an unexpected error occurs, of course)
"""
d=self.__dict__
if d.has_key('_v_currentSheets'):
del d['_v_currentSheets']
return self._delegateToSheetProviders(name,xmlns,'_delPropertySheetFor')
def _delegateToSheetProviders(self,name,xmlns,mname):
dm = self.__dict__[_v_dm_]
self = self._canonicalForm()
if name:
for sp in dm._getProvidersFor(self,'sheet_names',(name,'*')):
s = getattr(sp,mname)(self, name=name, xmlns=xmlns)
if s is not None: return s
if xmlns:
for sp in dm._getProvidersFor(self,'sheet_xmlns',(xmlns,'*')):
s = getattr(sp,mname)(self, name=name, xmlns=xmlns)
if s is not None: return s
return None
def _v_currentSheets(self,_v_dm_=_v_dm_):
"""PropertySheets tuple (analagous to __propsets__)"""
l = []
for sp in self.__dict__[_v_dm_]._uniqueProviders(('sheets',)):
l.extend(list(sp._PropertySheetsFor(self)))
self._v_currentSheets = tuple(l)
return self._v_currentSheets
_v_currentSheets = ComputedAttribute(_v_currentSheets)
def manage_delete(self,_v_dm_=_v_dm_):
"""Delete this object"""
if self._rackMounted:
self.__dict__[_v_dm_]._objectDeleting(self)
return 'OK'
raise TypeError, "Not rack-mounted; please use container to delete"
meta_type = "Data Skin"
__ac_permissions__ = (
('Delete rack-mounted objects', ('manage_delete',)),
)
# DEPRECATED STUFF
def PropertySheets(self):
"""
Returns a 'propertysheets'-type object
DEPRECATED - use 'propertysheets' attribute instead.
"""
return self.propertysheets
def PropertySheet(self, name='', xmlns=''):
"""
Return a specific property sheet (DEPRECATED)
Doesn't work w/ZClass sheets! Use propertysheets.get() instead.
"""
return self._delegateToSheetProviders(name,xmlns,'_PropertySheetFor')
_v_status_ = ''
default__class_init__(DataSkin)
class SkinZISS(ZInstanceSheetsSheet):
manage_addDataSkinSheetForm = genericAddForm(DataSkinSheet)
def manage_addDataSkinSheet(self, id, title, REQUEST=None):
"""Add a DataSkin sheet"""
o=DataSkinSheet(id, title)
self._setObject(id, o)
if REQUEST is not None: return self.manage_main(self, REQUEST)
meta_types = (
{'name':DataSkinSheet.meta_type, 'action':'manage_addDataSkinSheetForm'},
) + ZInstanceSheetsSheet.meta_types
class SZHolder:
""" """
def __init__(self):
ZClassSheets.__init__.im_func(self)
self.common=SkinZISS('common')
class _ZClass_for_DataSkin:
propertysheets = SZHolder()
_zclass_ = DataSkin
manage_options = ()
def initialize(context):
context.registerZClass(_ZClass_for_DataSkin)
ZPatterns/SkinScript/ 0040755 0001752 0000627 00000000000 07543611544 014501 5 ustar roche upfront ZPatterns/SkinScript/spark.py 0100644 0001752 0000627 00000033715 07543611361 016176 0 ustar roche upfront # Copyright (c) 1998-2000 John Aycock
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
__version__ = 'SPARK-0.6.1'
import re
import sys
import string
def _namelist(instance):
namelist, namedict, classlist = [], {}, [instance.__class__]
for c in classlist:
for b in c.__bases__:
classlist.append(b)
for name in dir(c):
if not namedict.has_key(name):
namelist.append(name)
namedict[name] = 1
return namelist
class GenericScanner:
def __init__(self):
pattern = self.reflect()
self.re = re.compile(pattern, re.VERBOSE)
self.index2func = {}
for name, number in self.re.groupindex.items():
self.index2func[number-1] = getattr(self, 't_' + name)
def makeRE(self, name):
doc = getattr(self, name).__doc__
rv = '(?P<%s>%s)' % (name[2:], doc)
return rv
def reflect(self):
rv = []
for name in _namelist(self):
if name[:2] == 't_' and name != 't_default':
rv.append(self.makeRE(name))
rv.append(self.makeRE('t_default'))
return string.join(rv, '|')
def error(self, s, pos):
print "Lexical error at position %s" % pos
raise SystemExit
def tokenize(self, s):
pos = 0
n = len(s)
while pos < n:
m = self.re.match(s, pos)
if m is None:
self.error(s, pos)
groups = m.groups()
for i in range(len(groups)):
if groups[i] and self.index2func.has_key(i):
self.index2func[i](groups[i])
pos = m.end()
def t_default(self, s):
r'( . | \n )+'
pass
class GenericParser:
def __init__(self, start):
self.rules = {}
self.rule2func = {}
self.rule2name = {}
self.collectRules()
self.startRule = self.augment(start)
self.ruleschanged = 1
_START = 'START'
_EOF = 'EOF'
#
# A hook for GenericASTBuilder and GenericASTMatcher.
#
def preprocess(self, rule, func): return rule, func
def addRule(self, doc, func):
rules = string.split(doc)
index = []
for i in range(len(rules)):
if rules[i] == '::=':
index.append(i-1)
index.append(len(rules))
for i in range(len(index)-1):
lhs = rules[index[i]]
rhs = rules[index[i]+2:index[i+1]]
rule = (lhs, tuple(rhs))
rule, fn = self.preprocess(rule, func)
if self.rules.has_key(lhs):
self.rules[lhs].append(rule)
else:
self.rules[lhs] = [ rule ]
self.rule2func[rule] = fn
self.rule2name[rule] = func.__name__[2:]
self.ruleschanged = 1
def collectRules(self):
for name in _namelist(self):
if name[:2] == 'p_':
func = getattr(self, name)
doc = func.__doc__
self.addRule(doc, func)
def augment(self, start):
#
# Tempting though it is, this isn't made into a call
# to self.addRule() because the start rule shouldn't
# be subject to preprocessing.
#
startRule = (self._START, ( start, self._EOF ))
self.rule2func[startRule] = lambda args: args[0]
self.rules[self._START] = [ startRule ]
self.rule2name[startRule] = ''
return startRule
def makeFIRST(self):
union = {}
self.first = {}
for rulelist in self.rules.values():
for lhs, rhs in rulelist:
if not self.first.has_key(lhs):
self.first[lhs] = {}
if len(rhs) == 0:
self.first[lhs][None] = 1
continue
sym = rhs[0]
if not self.rules.has_key(sym):
self.first[lhs][sym] = 1
else:
union[(sym, lhs)] = 1
changes = 1
while changes:
changes = 0
for src, dest in union.keys():
destlen = len(self.first[dest])
self.first[dest].update(self.first[src])
if len(self.first[dest]) != destlen:
changes = 1
#
# An Earley parser, as per J. Earley, "An Efficient Context-Free
# Parsing Algorithm", CACM 13(2), pp. 94-102. Also J. C. Earley,
# "An Efficient Context-Free Parsing Algorithm", Ph.D. thesis,
# Carnegie-Mellon University, August 1968, p. 27.
#
def typestring(self, token):
return None
def error(self, token):
print "Syntax error at or near `%s' token" % token
raise SystemExit
def parse(self, tokens):
tree = {}
tokens.append(self._EOF)
states = { 0: [ (self.startRule, 0, 0) ] }
if self.ruleschanged:
self.makeFIRST()
for i in xrange(len(tokens)):
states[i+1] = []
if states[i] == []:
break
self.buildState(tokens[i], states, i, tree)
#_dump(tokens, states)
if i < len(tokens)-1 or states[i+1] != [(self.startRule, 2, 0)]:
del tokens[-1]
self.error(tokens[i-1])
rv = self.buildTree(tokens, tree, ((self.startRule, 2, 0), i+1))
del tokens[-1]
return rv
def buildState(self, token, states, i, tree):
needsCompletion = {}
state = states[i]
predicted = {}
for item in state:
rule, pos, parent = item
lhs, rhs = rule
#
# A -> a . (completer)
#
if pos == len(rhs):
if len(rhs) == 0:
needsCompletion[lhs] = (item, i)
for pitem in states[parent]:
if pitem is item:
break
prule, ppos, pparent = pitem
plhs, prhs = prule
if prhs[ppos:ppos+1] == (lhs,):
new = (prule,
ppos+1,
pparent)
if new not in state:
state.append(new)
tree[(new, i)] = [(item, i)]
else:
tree[(new, i)].append((item, i))
continue
nextSym = rhs[pos]
#
# A -> a . B (predictor)
#
if self.rules.has_key(nextSym):
#
# Work on completer step some more; for rules
# with empty RHS, the "parent state" is the
# current state we're adding Earley items to,
# so the Earley items the completer step needs
# may not all be present when it runs.
#
if needsCompletion.has_key(nextSym):
new = (rule, pos+1, parent)
olditem_i = needsCompletion[nextSym]
if new not in state:
state.append(new)
tree[(new, i)] = [olditem_i]
else:
tree[(new, i)].append(olditem_i)
#
# Has this been predicted already?
#
if predicted.has_key(nextSym):
continue
predicted[nextSym] = 1
ttype = token is not self._EOF and \
self.typestring(token) or \
None
if ttype is not None:
#
# Even smarter predictor, when the
# token's type is known. The code is
# grungy, but runs pretty fast. Three
# cases are looked for: rules with
# empty RHS; first symbol on RHS is a
# terminal; first symbol on RHS is a
# nonterminal (and isn't nullable).
#
for prule in self.rules[nextSym]:
new = (prule, 0, i)
prhs = prule[1]
if len(prhs) == 0:
state.append(new)
continue
prhs0 = prhs[0]
if not self.rules.has_key(prhs0):
if prhs0 != ttype:
continue
else:
state.append(new)
continue
first = self.first[prhs0]
if not first.has_key(None) and \
not first.has_key(ttype):
continue
state.append(new)
continue
for prule in self.rules[nextSym]:
#
# Smarter predictor, as per Grune &
# Jacobs' _Parsing Techniques_. Not
# as good as FIRST sets though.
#
prhs = prule[1]
if len(prhs) > 0 and \
not self.rules.has_key(prhs[0]) and \
token != prhs[0]:
continue
state.append((prule, 0, i))
#
# A -> a . c (scanner)
#
elif token == nextSym:
#assert new not in states[i+1]
states[i+1].append((rule, pos+1, parent))
def buildTree(self, tokens, tree, root):
stack = []
self.buildTree_r(stack, tokens, -1, tree, root)
return stack[0]
def buildTree_r(self, stack, tokens, tokpos, tree, root):
(rule, pos, parent), state = root
while pos > 0:
want = ((rule, pos, parent), state)
if not tree.has_key(want):
#
# Since pos > 0, it didn't come from closure,
# and if it isn't in tree[], then there must
# be a terminal symbol to the left of the dot.
# (It must be from a "scanner" step.)
#
pos = pos - 1
state = state - 1
stack.insert(0, tokens[tokpos])
tokpos = tokpos - 1
else:
#
# There's a NT to the left of the dot.
# Follow the tree pointer recursively (>1
# tree pointers from it indicates ambiguity).
# Since the item must have come about from a
# "completer" step, the state where the item
# came from must be the parent state of the
# item the tree pointer points to.
#
children = tree[want]
if len(children) > 1:
child = self.ambiguity(children)
else:
child = children[0]
tokpos = self.buildTree_r(stack,
tokens, tokpos,
tree, child)
pos = pos - 1
(crule, cpos, cparent), cstate = child
state = cparent
lhs, rhs = rule
result = self.rule2func[rule](stack[:len(rhs)])
stack[:len(rhs)] = [result]
return tokpos
def ambiguity(self, children):
#
# XXX - problem here and in collectRules() if the same
# rule appears in >1 method. But in that case the
# user probably gets what they deserve :-) Also
# undefined results if rules causing the ambiguity
# appear in the same method.
#
sortlist = []
name2index = {}
for i in range(len(children)):
((rule, pos, parent), index) = children[i]
lhs, rhs = rule
name = self.rule2name[rule]
sortlist.append((len(rhs), name))
name2index[name] = i
sortlist.sort()
list = map(lambda (a,b): b, sortlist)
return children[name2index[self.resolve(list)]]
def resolve(self, list):
#
# Resolve ambiguity in favor of the shortest RHS.
# Since we walk the tree from the top down, this
# should effectively resolve in favor of a "shift".
#
return list[0]
#
# GenericASTBuilder automagically constructs a concrete/abstract syntax tree
# for a given input. The extra argument is a class (not an instance!)
# which supports the "__setslice__" and "__len__" methods.
#
# XXX - silently overrides any user code in methods.
#
class GenericASTBuilder(GenericParser):
def __init__(self, AST, start):
GenericParser.__init__(self, start)
self.AST = AST
def preprocess(self, rule, func):
rebind = lambda lhs, self=self: \
lambda args, lhs=lhs, self=self: \
self.buildASTNode(args, lhs)
lhs, rhs = rule
return rule, rebind(lhs)
def buildASTNode(self, args, lhs):
children = []
for arg in args:
if isinstance(arg, self.AST):
children.append(arg)
else:
children.append(self.terminal(arg))
return self.nonterminal(lhs, children)
def terminal(self, token): return token
def nonterminal(self, type, args):
rv = self.AST(type)
rv[:len(args)] = args
return rv
#
# GenericASTTraversal is a Visitor pattern according to Design Patterns. For
# each node it attempts to invoke the method n_, falling
# back onto the default() method if the n_* can't be found. The preorder
# traversal also looks for an exit hook named n__exit (no default
# routine is called if it's not found). To prematurely halt traversal
# of a subtree, call the prune() method -- this only makes sense for a
# preorder traversal. Node type is determined via the typestring() method.
#
class GenericASTTraversalPruningException:
pass
class GenericASTTraversal:
def __init__(self, ast):
self.ast = ast
def typestring(self, node):
return node.type
def prune(self):
raise GenericASTTraversalPruningException
def preorder(self, node=None):
if node is None:
node = self.ast
try:
name = 'n_' + self.typestring(node)
if hasattr(self, name):
func = getattr(self, name)
func(node)
else:
self.default(node)
except GenericASTTraversalPruningException:
return
for kid in node:
self.preorder(kid)
name = name + '_exit'
if hasattr(self, name):
func = getattr(self, name)
func(node)
def postorder(self, node=None):
if node is None:
node = self.ast
for kid in node:
self.postorder(kid)
name = 'n_' + self.typestring(node)
if hasattr(self, name):
func = getattr(self, name)
func(node)
else:
self.default(node)
def default(self, node):
pass
#
# GenericASTMatcher. AST nodes must have "__getitem__" and "__cmp__"
# implemented.
#
# XXX - makes assumptions about how GenericParser walks the parse tree.
#
class GenericASTMatcher(GenericParser):
def __init__(self, start, ast):
GenericParser.__init__(self, start)
self.ast = ast
def preprocess(self, rule, func):
rebind = lambda func, self=self: \
lambda args, func=func, self=self: \
self.foundMatch(args, func)
lhs, rhs = rule
rhslist = list(rhs)
rhslist.reverse()
return (lhs, tuple(rhslist)), rebind(func)
def foundMatch(self, args, func):
func(args[-1])
return args[-1]
def match_r(self, node):
self.input.insert(0, node)
children = 0
for child in node:
if children == 0:
self.input.insert(0, '(')
children = children + 1
self.match_r(child)
if children > 0:
self.input.insert(0, ')')
def match(self, ast=None):
if ast is None:
ast = self.ast
self.input = []
self.match_r(ast)
self.parse(self.input)
def resolve(self, list):
#
# Resolve ambiguity in favor of the longest RHS.
#
return list[-1]
def _dump(tokens, states):
for i in range(len(states)):
print 'state', i
for (lhs, rhs), pos, parent in states[i]:
print '\t', lhs, '::=',
print string.join(rhs[:pos]),
print '.',
print string.join(rhs[pos:]),
print ',', parent
if i < len(tokens):
print
print 'token', str(tokens[i])
print
ZPatterns/SkinScript/Methods.py 0100644 0001752 0000627 00000012250 07543611361 016450 0 ustar roche upfront from Products.ZPatterns.Providers import NullProvider
from Products.ZPatterns.Proxy import ProxyManager
from Products.ZPatterns.PlugIns import PlugIn, defaultConstructors
from Compiler import compile
from Globals import DTMLFile, default__class_init__
from DateTime.DateTime import DateTime
from OFS.SimpleItem import Item
from OFS import History
class SSMethod(PlugIn, NullProvider, ProxyManager, History.Historical):
"""SkinScript Method"""
__plugin_kind__ = "Attribute Provider"
meta_type = "SkinScript Method"
manage_options = (
{'label':'Edit', 'action':'manage_main', 'help': ('ZPatterns','SkinScriptSyntax.stx')},
) + ProxyManager.manage_options + History.Historical.manage_options + Item.manage_options
def manage_historyCompare(self, rev1, rev2, REQUEST,
historyComparisonResults=''):
return SSMethod.inheritedAttribute('manage_historyCompare')(
self, rev1, rev2, REQUEST,
historyComparisonResults=History.html_diff(
rev1.text, rev2.text
))
text = ''
_providers = ()
def _propertiesChanged(self):
providers = self._providers = compile(self.text)
for p in providers:
p._proxy_roles = self._proxy_roles
p.id = '%s, line %d' % (self.id,p.lineno); p.title = self.title
self.aq_inner.aq_parent.manage_refreshPlugIns()
def _getProviders(self):
return self._providers
manage_main=DTMLFile('methodEdit',globals())
def manage_edit(self, title, text, SUBMIT=None,
dtpref_cols='50', dtpref_rows='20', REQUEST=None):
"""Change the method"""
if self._size_changes.has_key(SUBMIT):
return self._er(text,title,SUBMIT,dtpref_cols,dtpref_rows,REQUEST)
self._validateProxy(REQUEST)
if self._size_changes.has_key(SUBMIT):
return self._er(text, title, SUBMIT, dtpref_cols,
dtpref_rows, REQUEST)
if type(text) is not type(''):
text = text.read()
self.text, self.title = text, title
self._propertiesChanged()
if REQUEST:
message = "Contents updated."
return self.manage_main(self, REQUEST, manage_tabs_message=message)
_size_changes={
'Bigger': (5,5),
'Smaller': (-5,-5),
'Narrower': (0,-5),
'Wider': (0,5),
'Taller': (5,0),
'Shorter': (-5,0),
}
def _er(self,text,title,SUBMIT,dtpref_cols,dtpref_rows,REQUEST):
dr,dc = self._size_changes[SUBMIT]
from string import atoi
rows=max(1,atoi(dtpref_rows)+dr)
cols=max(40,atoi(dtpref_cols)+dc)
e=(DateTime('GMT') + 365).rfc822()
resp=REQUEST['RESPONSE']
resp.setCookie('dtpref_rows',str(rows),path='/',expires=e)
resp.setCookie('dtpref_cols',str(cols),path='/',expires=e)
return self.manage_main(self, REQUEST, title=title,
text=text, dtpref_cols=cols, dtpref_rows=rows)
def manage_upload(self,file='', REQUEST=None):
"""Replace the contents of the method with the text in file."""
self._validateProxy(REQUEST)
if type(file) is not type(''): file=file.read()
self.text = file; self._propertiesChanged()
if REQUEST:
return self.manage_main(self, REQUEST,
manage_tabs_message="Contents updated.")
def PrincipiaSearchSource(self):
"Support for searching - the document's contents are searched."
return self.text
def manage_FTPget(self):
"Get source for FTP download"
self.REQUEST.RESPONSE.setHeader('Content-Type', 'text/plain')
return self.read()
def PUT(self, REQUEST, RESPONSE):
"""Handle HTTP PUT requests."""
self.dav__init(REQUEST, RESPONSE)
body=REQUEST.get('BODY', '')
self._validateProxy(REQUEST)
self.text=body; self._propertiesChanged()
RESPONSE.setStatus(204)
return RESPONSE
manage_FTPput = PUT
def read(self):
return self.text
def get_size(self):
return len(self.text)
getSize = get_size
def manage_proxy(self, roles=(), REQUEST=None):
"Change Proxy Roles"
r = ProxyManager.manage_proxy.im_func(self,roles,REQUEST)
# Update proxy roles on providers, and reload them into parent
for p in self._providers: p._proxy_roles = self._proxy_roles
self.aq_inner.aq_parent.manage_refreshPlugIns()
return r
__ac_permissions__ = (
('Change proxy roles', ('manage_proxy')),
('View management screens', ('manage_uploadForm','manage_main',
'PrincipiaSearchSource')),
('Change SkinScript methods',('manage_upload','PUT','manage_edit',
'manage_FTPget')),
)
default__class_init__(SSMethod)
def initialize(context):
context.registerPlugInClass(
SSMethod,
permission = 'Add SkinScript Methods',
constructors = defaultConstructors(SSMethod,globals()),
icon = 'www/SkinScriptMethod.gif'
)
ZPatterns/SkinScript/methodEdit.dtml 0100644 0001752 0000627 00000003606 07543611361 017450 0 ustar roche upfront
You may edit the source for this method using the form below. You
may also upload the source for this method from a local file. Click
the browse button to select a local file to upload.
ZPatterns/SkinScript/Components.py 0100644 0001752 0000627 00000005631 07543611361 017177 0 ustar roche upfront from OFS.SimpleItem import Item
from Acquisition import Implicit
from Products.ZPatterns.Providers import NullProvider
from Products.ZPatterns.Agents import AgentMixin, GTMixin
from Products.ZPatterns.AttributeProviders import GAPMixin, NOT_FOUND
from Products.ZPatterns.Expressions import NamespaceStack, pushProxy, popProxy
from DocumentTemplate.DT_Util import InstanceDict
class Compute(GAPMixin,NullProvider,Item,Implicit):
"""
Compiler output for "WITH fromexpr COMPUTE assignments"
"""
def __init__(self,fromexpr,assignlist,is_query=None,defaults=(),
dependencies=()):
self._fromex = fromexpr
self.Attributes = assignlist
self.dependencies = dependencies
if defaults: self.Defaults = defaults
if is_query: self.IsQuery = is_query
class Trigger(GTMixin,AgentMixin,NullProvider,Item,Implicit):
"""
Compiler output for WHEN ... STORE/CALL ... SAVING ... type statements
"""
def __init__(self,events,saveattrs,callexpr,mementos,
onlySave=None,isIndexing=None):
self._mementos = mementos
self.handle_set_for = saveattrs
self._expr = callexpr
self.applicable_events = events
if onlySave: self._onlySaveAttrs=1
if isIndexing: self._isIndexingAgent=1
class Initialize(NullProvider,Item,Implicit):
def __init__(self,computelist):
self.Attributes = computelist
def namesForRegistration(self,container):
return { 'provides': ('handlers',) }
def _objectCreating(self,client):
t = NamespaceStack()
pushProxy(self)
try:
data = {'self':client, 'NOT_FOUND':NOT_FOUND, 'RESULT':client}
t._push(InstanceDict(client, t))
t._push(data)
try:
c = client._getCache()
for a,e in self.Attributes:
c[a] = e.eval(t)
finally:
t._pop(2)
finally:
popProxy(self)
class PersistAttrs(NullProvider,Item,Implicit):
"""
Compiler output for "STORE attrs IN SELF" statements
"""
def __init__(self,attrlist):
self.Attributes = attrlist
def namesForRegistration(self,container):
return {
'provides':('attributes',),
'setattr': self.Attributes, 'delattr': self.Attributes
}
def _SetAttributeFor(self,client,name,value):
"""Set the attribute and return true if successful"""
client.__dict__[name]=value; client._p_changed = 1
return 1
def _DelAttributeFor(self,client,name):
"""Delete the attribute and return true if successful"""
if client._v_changedAttrs_[name] is NOT_FOUND: del client._v_changedAttrs_[name]
return 1 # Nothing else to do, since DataSkin has already deleted persistent attr
ZPatterns/SkinScript/__init__.py 0100644 0001752 0000627 00000000113 07543611361 016577 0 ustar roche upfront import Methods
def initialize(context):
Methods.initialize(context)
ZPatterns/SkinScript/Compiler.py 0100644 0001752 0000627 00000035071 07543611361 016625 0 ustar roche upfront from string import join,split,strip
import tokenize, cStringIO
from spark import GenericParser
class Token:
def __init__(self, type, attr=None, lineno='???'):
self.type = type
self.attr = attr
self.lineno = lineno
def __cmp__(self, o):
return cmp(self.type, o)
###
def __getitem__(self,key): raise IndexError,key
def __repr__(self):
return "%s(%s)" % (self.type,self.attr)
def __len__(self): return 0
def __str__(self):
return str(self.attr or self.type)
_map = {
tokenize.ENDMARKER : 'ENDMARKER',
tokenize.NAME : 'NAME',
tokenize.NUMBER : 'NUMBER',
tokenize.STRING : 'STRING',
tokenize.NEWLINE : 'NEWLINE',
tokenize.INDENT : 'INDENT',
tokenize.DEDENT : 'DEDENT', }
_rw = {
'and' : None, 'assert' : None,
'break' : None, 'class' : None,
'continue' : None, 'def' : None,
'del' : None, 'elif' : None,
'else' : None, 'except' : None,
'exec' : None, 'finally' : None,
'for' : None, 'from' : None,
'global' : None, 'if' : None,
'import' : None, 'in' : None,
'is' : None, 'lambda' : None,
'not' : None, 'or' : None,
'pass' : None, 'print' : None,
'raise' : None, 'return' : None,
'try' : None, 'while' : None,
}
kw = """
WITH COMPUTE SELF WHEN OBJECT ADDED DELETED CHANGED STORE USING CALL SAVING IN
QUERY OTHERWISE LET INITIALIZE DEPENDENT ON INDEX CALLING
"""
_kw={}
for k in split(strip(kw)): _kw[k]=None
is_kw = _kw.has_key
def scan(f):
tokens = []
def callback(value, lexeme, (lineno, column), end, line, list=tokens):
attr = None
type = lexeme
if value in (tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE, tokenize.INDENT, tokenize.DEDENT):
return
elif _map.has_key(value):
if is_kw(lexeme):
type = lexeme
elif value != tokenize.NAME or not _rw.has_key(lexeme):
attr = lexeme
type = _map[value]
t = Token(type, attr=attr, lineno=lineno)
list.append(t)
tokenize.tokenize(f.readline, callback)
return tokens
class AST:
def __init__(self, type):
self.type = type
self._kids = []
def __getitem__(self, i):
return self._kids[i]
def __len__(self):
return len(self._kids)
def __setslice__(self, low, high, seq):
self._kids[low:high] = seq
def __cmp__(self, o):
return cmp(self.type, o)
def __str__(self):
return join(map(str,self._kids),'')
def __getslice__(self, low, high):
return self._kids[low:high]
def __repr__(self):
return self.type+`self[:]`
if __name__=='__main__':
# Debugging versions of compiler output
class Compute(AST):
type = 'COMPUTE'
def __init__(self,*args,**kw):
self._kids=list(args)+kw.items()
class Trigger(Compute):
type="TRIGGER"
class PersistAttrs(AST):
type="PERSIST"
def __init__(self,args):
self._kids = list(args)
class Expression(AST):
def __init__(self,expr):
self.expr = expr
def __repr__(self): return 'EXPR(%s)' % self.expr
def __str__(self): return self.expr
class Initialize(Compute):
type="INITIALIZE"
class Name(Compute):
type="NAME"
else:
from Components import Compute, Trigger, PersistAttrs, Initialize
from Products.ZPatterns.Expressions import Expression, Name
class SkinScriptParser(GenericParser):
def __init__(self, start='script'):
GenericParser.__init__(self, start)
def typestring(self, token):
return token.type
def error(self, token):
raise SyntaxError, "Syntax error at `%s' (line %s)" % (token, token.lineno)
def p_script(self,args):
"""
statement ::= compute
statement ::= persist
statement ::= trigger
statement ::= indexer
statement ::= saver
statement ::= store
statement ::= initialize
script ::= statements ENDMARKER
name_or_assign ::= assign
name_or_assign ::= uncalled_name
self_or_expr ::= self_as_none
self_or_expr ::= py_expr
opt_saving ::= saving_clause
memento ::= assign
memento ::= called_name
"""
return args[0]
def p_py_expr(self,args):
"""
py_expr ::= testlist
assign_expr ::= test
"""
return Expression(args[0])
def p_statements(self,args):
"""
statements ::= statements statement
statements ::= statement
attrspeclist ::= attrspeclist , attributespec
attrspeclist ::= attributespec
assignmentlist ::= assignmentlist , name_or_assign
assignmentlist ::= name_or_assign
assignonlylist ::= assignonlylist , assign
assignonlylist ::= assign
mementolist ::= mementolist , memento
mementolist ::= memento
eventlist ::= eventlist , event
eventlist ::= event
namelist ::= namelist , simple_name
namelist ::= simple_name
"""
if len(args)>1:
a = args[0]; a.append(args[-1]); return a
else:
return [args[0]]
def p_trigger(self,args):
"""
trigger ::= when_clause CALL py_expr opt_saving
"""
t = Trigger(args[0],[], args[2],args[3])
t.lineno = args[1].lineno
return t
def p_indexer(self,args):
"""
indexer ::= when_clause INDEX CALLING py_expr opt_saving
"""
t = Trigger(args[0],[], args[3],args[4],isIndexing=1)
t.lineno = args[1].lineno
return t
def p_saver(self,args):
"""
saver ::= when_clause STORE attrspeclist USING py_expr opt_saving
"""
t = Trigger(args[0],args[2],args[4],args[5], onlySave=1)
t.lineno = args[1].lineno
return t
def p_compute(self,args):
"""
compute ::= WITH self_or_expr COMPUTE assignmentlist optional_defaultattrs optional_dependency
"""
c = Compute(args[1],args[3],defaults=args[4],dependencies=args[5])
c.lineno = args[0].lineno; return c
def p_compute_query(self,args):
"""
compute ::= WITH QUERY py_expr COMPUTE assignmentlist optional_defaultattrs optional_dependency
"""
c = Compute(args[2],args[4],is_query=1,defaults=args[5],dependencies=args[6])
c.lineno = args[0].lineno; return c
def p_initialize(self,args):
"""
initialize ::= INITIALIZE OBJECT WITH assignonlylist
"""
c = Initialize(args[-1]); c.lineno = args[0].lineno; return c
def p_persist(self,args):
"""
persist ::= STORE attrspeclist IN SELF
"""
p = PersistAttrs(args[1])
p.lineno = args[0].lineno
return p
def p_store(self,args):
"""
store ::= STORE attrspeclist USING py_expr opt_saving
"""
t = Trigger(
('ADD','DELETE','CHANGE'), args[1],args[3],args[4], onlySave=1
)
t.lineno = args[0].lineno
return t
def p_optional_defaultattrs(self,args):
"""
optional_defaultattrs ::= OTHERWISE LET assignonlylist
optional_defaultattrs ::=
"""
if len(args): return args[2]
return ()
def p_optional_dependency(self,args):
"""
optional_dependency ::= DEPENDENT ON namelist
optional_dependency ::=
"""
if len(args): return args[2]
return ()
def p_simple_name(self,args):
"""
simple_name ::= NAME
"""
return (str(args[0]))
def p_event(self,args):
"""
event ::= ADDED
event ::= DELETED
event ::= CHANGED
attributespec ::= NAME
attributespec ::= *
"""
return str(args[0])
def p_called_name(self,args):
"""
called_name ::= NAME
"""
name = str(args[0])
return (name,Name(name,1))
def p_uncalled_name(self,args):
"""
uncalled_name ::= NAME
"""
name = str(args[0])
return (name,Name(name,0))
def p_assign(self,args):
"""
assign ::= NAME = assign_expr
"""
return (str(args[0]),args[2])
def p_self_as_none(self,args):
"""
self_as_none ::= SELF
"""
return None
def p_opt_saving(self,args):
"""
opt_saving ::=
"""
return []
def p_when_clause(self,args):
"""
when_clause ::= WHEN OBJECT eventlist
"""
m = {'ADDED':'ADD','CHANGED':'CHANGE','DELETED':'DELETE'}.get
return tuple(map(m,args[2]))
def p_saving_clause(self,args):
"""
saving_clause ::= SAVING mementolist
"""
return args[1]
def p_testlist(self, args):
'''
varargslist ::= extraargs
varargslist ::= primaryargs , extraargs
varargslist ::= primaryargs opt_comma
primaryargs ::= primaryargs , fpdef = test
primaryargs ::= primaryargs , fpdef
primaryargs ::= fpdef = test
primaryargs ::= fpdef
extraargs ::= * NAME
extraargs ::= * NAME , ** NAME
extraargs ::= * NAME , * * NAME
extraargs ::= ** NAME
extraargs ::= * * NAME
fpdef ::= NAME
fpdef ::= ( fplist )
fplist ::= bare_fplist opt_comma
bare_fplist ::= bare_fplist , fpdef
bare_fplist ::= fpdef
test ::= lambdef
test ::= or_test
or_test ::= or_test or and_test
or_test ::= and_test
and_test ::= and_test and not_test
and_test ::= not_test
not_test ::= not not_test
not_test ::= comparison
comparison ::= comparison comp_op expr
comparison ::= expr
comp_op ::= <
comp_op ::= >
comp_op ::= ==
comp_op ::= >=
comp_op ::= <=
comp_op ::= <>
comp_op ::= !=
comp_op ::= in
comp_op ::= not in
comp_op ::= is
comp_op ::= is not
expr ::= expr | xor_expr
expr ::= xor_expr
xor_expr ::= xor_expr ^ and_expr
xor_expr ::= and_expr
and_expr ::= and_expr & shift_expr
and_expr ::= shift_expr
shift_expr ::= shift_expr << arith_expr
shift_expr ::= shift_expr >> arith_expr
shift_expr ::= arith_expr
arith_expr ::= arith_expr + term
arith_expr ::= arith_expr - term
arith_expr ::= term
term ::= term * factor
term ::= term / factor
term ::= term % factor
term ::= factor
factor ::= + factor
factor ::= - factor
factor ::= ~ factor
factor ::= power
power ::= atom trailer_list power_list
power ::= atom trailer_list
power ::= atom power_list
power ::= atom
trailer_list ::= trailer_list trailer
trailer_list ::= trailer
power_list ::= power_list ** factor
power_list ::= ** factor
atom ::= ( testlist )
atom ::= ( )
atom ::= [ listmaker ]
atom ::= [ ]
atom ::= { dictmaker }
atom ::= { }
atom ::= ` testlist `
atom ::= NAME
atom ::= NUMBER
atom ::= string_list
string_list ::= string_list STRING
string_list ::= STRING
lambdef ::= lambda varargslist : test
lambdef ::= lambda : test
trailer ::= ( arglist )
trailer ::= ( )
trailer ::= [ subscriptlist ]
trailer ::= . NAME
subscriptlist ::= bare_subscriptlist opt_comma
bare_subscriptlist ::= bare_subscriptlist , subscript
bare_subscriptlist ::= subscript
subscript ::= . . .
subscript ::= test
subscript ::= opt_test : opt_test
subscript ::= opt_test : opt_test : opt_test
testlist ::= bare_testlist opt_comma
bare_testlist ::= bare_testlist , test
bare_testlist ::= test
dictmaker ::= bare_dictmaker opt_comma
bare_dictmaker ::= bare_dictmaker , test : test
bare_dictmaker ::= test : test
listmaker ::= testlist
listmaker ::= testlist list_for
list_iter ::= list_for
list_iter ::= list_if
list_for ::= for testlist in testlist opt_list_iter
list_if ::= if test opt_list_iter
opt_list_iter ::= list_iter
opt_list_iter ::=
arglist ::= bare_arglist opt_comma
bare_arglist ::= bare_arglist , argument
bare_arglist ::= argument
argument ::= test = test
argument ::= test
opt_test ::= test
opt_test ::=
opt_comma ::= ,
opt_comma ::=
'''
return join(map(str,args),' ')
def parse(tokens,start='script'):
parser = SkinScriptParser(start=start)
return tuple(parser.parse(tokens))
def scans(s): return scan(cStringIO.StringIO(s))
def compile(s): return parse(scans(s))
if __name__=='__main__':
t=scans(
"""
WITH 1+2 COMPUTE foo,bar=baz
STORE foo,bar,wazoo IN SELF
STORE spam USING foobly+1 SAVING wahoo=(99),shiz,fez=bez
WITH SELF COMPUTE blah=shazam
WHEN OBJECT DELETED CALL pasta() SAVING pizza,fruit=(nuts),pizza
WHEN OBJECT ADDED,CHANGED STORE dessert USING freezer
WITH gazoo*3 COMPUTE spam
"""
)
p=parse(t)
print
for j in p: print `j`
ZPatterns/DynPersist.so 0100755 0001752 0000627 00000022573 07543611361 015065 0 ustar roche upfront ELF 0
4 4 ( # # ( $ $ % 6 ) # 5 , 4 1 + % 0 3 - 2 " $ ( . / ! * ' & h \ 0
0
# $ $ d% l% t% % % $ S ~ " i H / ; " 4 % q u W 5 %
t% & _DYNAMIC _GLOBAL_OFFSET_TABLE_ __gmon_start__ _init _fini __deregister_frame_info __register_frame_info PyErr_Fetch PyExc_AttributeError PyErr_Restore PyErr_Clear PyTuple_New PyObject_CallObject PyObject_CallMethod PyString_Type PyString_AsString initDynPersist PyImport_ImportModule PyObject_GetAttrString PyCObject_AsVoidPtr Py_InitModule4 PyString_InternFromString PyModule_GetDict PyString_FromString PyDict_SetItemString PyErr_Occurred Py_FatalError libc.so.6 _edata __bss_start _end GLIBC_2.0 ii
# ,$ x$ |$ % % % " % , % 5 % % % % % % % ! % " % $ % % % & % ' % ( % ) % + % - % . % / % 4 US [à P : [ h h h h h h( $ h0 ( h8 p, h@ `0 hH P4 hP @8 hX 0< h` @ hh D hp H hx L h P h T h US [8 h t[É $US p uBlPl Ћl8 u` t,Pǃp ]]Ë $USÜ []Ð $USÀ \ tl P,P]]Ë $USD []Ðt& $U WVS" }u VW@ЉE EPEPEPUt uFV@ЃU
uBR@ЃUE E썃E PǃtNUԃRWfƃt%VE> uFV@ЃuGW@ЃUEY h j PPVǃ P} Ph PP W!E PPPEP8 u uvUE RvƃtNEԃPV@ǃt%WE? uGW@ЃuFV@ЃEU؉t RURUR Ѓt,Ple[^_]É $UVSó u X 19FuVu1v PQVEPBЍe[^]
$UVSC t Ѓ>u[^]Ë $US []Í ' US [ [ O __of__ cPersistence.Persistent subclass supporting __getattr__ DynPersist ExtensionClass CAPI cPersistence Persistent's with __getattr__! __get_attr__ __set_attr__ __del_attr__ 0.2 __version__ can't initialize module PersistWithGetattr p% $ @
h
t% 0 H o o o\ $ & 6 F V f v
&
GCC: (GNU) 2.95.3 20010315 (release) GCC: (GNU) 2.95.3 20010315 (release) GCC: (GNU) 2.95.3 20010315 (release) GCC: (GNU) 2.95.3 20010315 (release) GCC: (GNU) 2.95.3 20010315 (release) 01.01 01.01 01.01 01.01 01.01 .symtab .strtab .shstrtab .hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.data .rel.got .rel.plt .init .text .fini .rodata .eh_frame .dynamic .ctors .dtors .sbss .bss .comment .note t ! ` ) h h 1 o \ \ l > o M W ( ` 0 0
i % d @ o 0
0
P u { @ Q # $ $ d% d l% l [ t% t l % % ( d A ! h \ 0
0
# $ $ d% l% t% % % 0
0
+ `
6 # : l% H # T d
j $ }
%
$ # d% + $ h% \ $ p% $ @ $ % $ / D = % J <
U % f & s & $ t ] $ ~ " # ) @ " c r % ( B P V % ] t% s & x initfini.c gcc2_compiled. call_gmon_start crtstuff.c p.3 __DTOR_LIST__ completed.4 __do_global_dtors_aux __EH_FRAME_BEGIN__ fini_dummy object.11 frame_dummy init_dummy force_to_data __CTOR_LIST__ __do_global_ctors_aux __CTOR_END__ __DTOR_END__ __FRAME_END__ DynPersist.c PyExtensionClassCAPI dpMethods getattro_hook __get_attr__ p_setattro cPersistenceCAPI __del_attr__ __set_attr__ DynPersistType.375 p_getattro _DYNAMIC PyString_Type __register_frame_info@@GLIBC_2.0 PyErr_Restore PyDict_SetItemString PyErr_Fetch PyErr_Occurred Py_InitModule4 _init PyObject_GetAttrString __deregister_frame_info@@GLIBC_2.0 initDynPersist PyImport_ImportModule PyErr_Clear PyString_AsString PyString_FromString PyCObject_AsVoidPtr PyObject_CallMethod __bss_start PyModule_GetDict PyExc_AttributeError PyObject_CallObject PyString_InternFromString Py_FatalError _fini _edata _GLOBAL_OFFSET_TABLE_ _end PyTuple_New __gmon_start__