Merge lp:~justas.sadzevicius/schooltool/catalogs into lp:schooltool/1.7

[Justas Sadzevičius]

New-style catalogs should not fall to ST in Lucid, so... merge to 1.5?

=== modified file 'src/schooltool/app/app.py'
--- src/schooltool/app/app.py	2010-02-09 16:54:13 +0000
+++ src/schooltool/app/app.py	2010-05-28 11:09:37 +0000
@@ -28,11 +28,9 @@
 from persistent.dict import PersistentDict
 
 from zope.location.location import LocationProxy
-from zope.component import adapter
-from zope.component import adapts
+from zope.component import adapter, adapts
 from zope.i18n import translate
-from zope.interface import implementer
-from zope.interface import implements, implementsOnly
+from zope.interface import implementer, implements, implementsOnly
 
 from zope.annotation.interfaces import IAttributeAnnotatable, IAnnotations
 from zope.app.applicationcontrol.interfaces import IApplicationControl
@@ -86,6 +84,8 @@
     title = property(_title)
 
 
+@adapter(None)
+@implementer(ISchoolToolApplication)
 def getSchoolToolApplication(ignore=None):
     """Return the nearest ISchoolToolApplication.
 
@@ -99,8 +99,7 @@
     candidate = getSite()
     if ISchoolToolApplication.providedBy(candidate):
         return candidate
-    else:
-        raise ValueError("can't get a SchoolToolApplication")
+    return None
 
 
 class SimpleNameChooser(NameChooser):

=== modified file 'src/schooltool/app/browser/app.py'
--- src/schooltool/app/browser/app.py	2010-01-19 16:41:42 +0000
+++ src/schooltool/app/browser/app.py	2010-05-28 11:09:37 +0000
@@ -45,7 +45,6 @@
 from schooltool.calendar.icalendar import convert_calendar_to_ical
 from schooltool.common import SchoolToolMessage as _
 from schooltool.app.browser.interfaces import IManageMenuViewletManager
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.app.interfaces import ISchoolToolAuthenticationPlugin
 from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.interfaces import IApplicationPreferences
@@ -63,7 +62,7 @@
     """A view for the main application."""
 
     def update(self):
-        prefs = IApplicationPreferences(getSchoolToolApplication())
+        prefs = IApplicationPreferences(ISchoolToolApplication(None))
         if prefs.frontPageCalendar:
             url = absoluteURL(ISchoolToolCalendar(self.context),
                               self.request)
@@ -275,7 +274,7 @@
     def __init__(self, context, request):
         BrowserView.__init__(self, context, request)
 
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         prefs = self.schema(app)
         initial = {}
         for field in self.schema:
@@ -292,7 +291,7 @@
             except WidgetsError:
                 return # Errors will be displayed next to widgets
 
-            app = getSchoolToolApplication()
+            app = ISchoolToolApplication(None)
             prefs = self.schema(app)
             for field in self.schema:
                 if field in data: # skip non-fields

=== modified file 'src/schooltool/app/browser/cal.py'
--- src/schooltool/app/browser/cal.py	2010-04-12 10:49:40 +0000
+++ src/schooltool/app/browser/cal.py	2010-05-28 11:09:37 +0000
@@ -77,7 +77,6 @@
 from schooltool.app.browser.interfaces import IEventForDisplay
 from schooltool.app.browser.interfaces import IHaveEventLegend
 from schooltool.app.interfaces import ISchoolToolCalendarEvent
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.app.interfaces import ISchoolToolCalendar
 from schooltool.app.interfaces import IHaveCalendar
 from schooltool.table.batch import IterableBatch
@@ -934,7 +933,7 @@
     timetable_template = ViewPageTemplateFile("templates/cal_weekly_timetable.pt")
 
     def __call__(self):
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         # XXX ttshemas were removed from app in evolve28.
         #     timetable_template can be killed now (maybe?).
         #     All related code should go to land of no return.
@@ -2477,7 +2476,7 @@
 
         elif "BOOK" in self.request: # and not self.update_status:
             self.update_status = ''
-            sb = getSchoolToolApplication()
+            sb = ISchoolToolApplication(None)
             for res_id, resource in sb["resources"].items():
                 if 'add_item.%s' % res_id in self.request:
                     booked = self.hasBooked(resource)
@@ -2488,7 +2487,7 @@
 
         elif "UNBOOK" in self.request:
             self.update_status = ''
-            sb = getSchoolToolApplication()
+            sb = ISchoolToolApplication(None)
             for res_id, resource in sb["resources"].items():
                 if 'remove_item.%s' % res_id in self.request:
                     booked = self.hasBooked(resource)
@@ -2502,7 +2501,7 @@
     @property
     def availableResources(self):
         """Gives us a list of all bookable resources."""
-        sb = getSchoolToolApplication()
+        sb = ISchoolToolApplication(None)
         calendar_owner = removeSecurityProxy(self.context.__parent__.__parent__)
         def isBookable(resource):
             if resource is calendar_owner:

=== modified file 'src/schooltool/app/browser/csvimport.py'
--- src/schooltool/app/browser/csvimport.py	2010-01-19 12:09:22 +0000
+++ src/schooltool/app/browser/csvimport.py	2010-05-28 11:09:37 +0000
@@ -27,7 +27,6 @@
 
 from schooltool.schoolyear.interfaces import ISchoolYear
 from schooltool.common import SchoolToolMessage as _
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.app.app import SimpleNameChooser
 from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.course.interfaces import ICourseContainer
@@ -260,7 +259,7 @@
     def __init__(self, container, charset=None):
         # XXX It appears that our security declarations are inadequate,
         #     because things break without this removeSecurityProxy.
-        self.app = getSchoolToolApplication()
+        self.app = ISchoolToolApplication(None)
         self.sections = removeSecurityProxy(container)
         self.persons = self.app['persons']
         self.errors = TimetableImportErrorCollection()

=== modified file 'src/schooltool/app/browser/overlay.py'
--- src/schooltool/app/browser/overlay.py	2009-11-30 18:56:52 +0000
+++ src/schooltool/app/browser/overlay.py	2010-05-28 11:09:37 +0000
@@ -31,8 +31,8 @@
 from zope.viewlet.viewlet import ViewletBase
 
 from schooltool.common import SchoolToolMessage as _
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.app.interfaces import ISchoolToolCalendar
+from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.interfaces import IShowTimetables
 from schooltool.person.interfaces import IPerson
 
@@ -159,7 +159,7 @@
         user = removeSecurityProxy(IPerson(self.request.principal, None))
         if user is None:
             return []
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
 
         result = []
         for obj in app[container].values():
@@ -179,7 +179,7 @@
         """
         user = IPerson(self.request.principal, None)
         if user:
-            app = getSchoolToolApplication()
+            app = ISchoolToolApplication(None)
             calendar = ISchoolToolCalendar(app)
             if canAccess(calendar, '__iter__'):
                 return {'title': app.title,

=== added file 'src/schooltool/app/catalog.py'
--- src/schooltool/app/catalog.py	1970-01-01 00:00:00 +0000
+++ src/schooltool/app/catalog.py	2010-05-28 11:09:37 +0000
@@ -0,0 +1,216 @@
+#
+# SchoolTool - common information systems platform for school administration
+# Copyright (c) 2010 Shuttleworth Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+"""
+SchoolTool catalogs.
+"""
+from zope.interface import implementer, implements, implementsOnly
+from zope.intid.interfaces import IIntIds, IIntIdAddedEvent, IIntIdRemovedEvent
+from zope.component import adapter, queryUtility, getUtility
+from zope.container import btree
+from zope.container.contained import Contained
+from zope.lifecycleevent import IObjectModifiedEvent
+
+from zc.catalog import extentcatalog
+from zc.catalog import catalogindex
+
+from schooltool.app.interfaces import ISchoolToolApplication
+from schooltool.app.interfaces import ICatalogStartUp
+from schooltool.app.interfaces import ICatalogs
+from schooltool.app.interfaces import IVersionedCatalog
+from schooltool.app.app import ActionBase
+from schooltool.table.catalog import FilterImplementing
+
+
+APP_CATALOGS_KEY = 'schooltool.app.catalog:Catalogs'
+
+
+class CatalogStartupBase(ActionBase):
+    implementsOnly(ICatalogStartUp)
+
+
+class Catalogs(btree.BTreeContainer):
+    implements(ICatalogs)
+
+
+@adapter(ISchoolToolApplication)
+@implementer(ICatalogs)
+def getAppCatalogs(app):
+    if APP_CATALOGS_KEY not in app:
+        app[APP_CATALOGS_KEY] = Catalogs()
+    return app[APP_CATALOGS_KEY]
+
+
+class VersionedCatalog(Contained):
+    implements(IVersionedCatalog)
+
+    expired = False
+    version = 0
+    catalog = None
+
+    def __init__(self, catalog, version):
+        self.catalog = catalog
+        self.catalog.__parent__ = self
+        self.catalog.__name__ = 'catalog'
+        self.version = version
+
+    def __repr__(self):
+        return '<%s v. %r>: %s' % (
+            self.__class__.__name__, self.version, self.catalog)
+
+
+class PrepareCatalogContainer(CatalogStartupBase):
+
+    def __call__(self):
+        catalogs = ICatalogs(self.app)
+        for entry in catalogs.values():
+            entry.expired = True
+
+
+class ExpiredCatalogCleanup(CatalogStartupBase):
+
+    def __call__(self):
+        catalogs = ICatalogs(self.app)
+        for key in list(catalogs):
+            if catalogs[key].expired:
+                del catalogs[key]
+
+
+class CatalogFactory(CatalogStartupBase):
+
+    after = ('prepare-catalog-container', )
+    before = ('expired-catalog-cleanup', )
+
+    version = u''
+
+    @classmethod
+    def key(cls):
+        return u'catalog:%s.%s' % (cls.__module__, cls.__name__)
+
+    @classmethod
+    def get(cls, ignored=None):
+        app = ISchoolToolApplication(None)
+        catalogs = ICatalogs(app)
+        entry = catalogs.get(cls.key())
+        if entry is None:
+            return None
+        return entry.catalog
+
+    def getVersion(self):
+        return unicode(self.version)
+
+    def createCatalog(self):
+        raise NotImplementedError()
+
+    def setIndexes(self, catalog):
+        raise NotImplementedError()
+
+    def __call__(self):
+        app = ISchoolToolApplication(None)
+        catalogs = ICatalogs(app)
+        key = self.key()
+        version = self.getVersion()
+
+        if key in catalogs:
+            if catalogs[key].version == version:
+                catalogs[key].expired = False
+            else:
+                del catalogs[key]
+
+        if key not in catalogs:
+            catalog = self.createCatalog()
+            catalogs[key] = VersionedCatalog(catalog, version)
+            # XXX: if setIndexes throw, delete the catalog and rethrow
+            self.setIndexes(catalog)
+
+
+class CatalogImplementing(CatalogFactory):
+    """Factory of catalogs containing objects implementing the given interface."""
+
+    interface = None # override in child classes
+
+    def createCatalog(self):
+        return extentcatalog.Catalog(
+            extentcatalog.FilterExtent(
+                FilterImplementing(self.interface)))
+
+    def getVersion(self):
+        return u'interface:%s, version:%s' % (
+            u'%s.%s' % (self.interface.__module__, self.interface.__name__),
+            super(CatalogImplementing, self).getVersion())
+
+
+class AttributeCatalog(CatalogImplementing):
+    """Catalog indexing specified attributes of objects implementing
+    the given interface."""
+
+    attributes = ()
+
+    def getVersion(self):
+        return u'attributes:%s, %s' % (
+            tuple(sorted(self.attributes)),
+            super(AttributeCatalog, self).getVersion())
+
+    def setIndexes(self, catalog):
+        for name in self.attributes:
+            catalog[name] = catalogindex.ValueIndex(name)
+
+
+@adapter(IIntIdAddedEvent)
+def indexDocSubscriber(event):
+    app = ISchoolToolApplication(None, None)
+    if app is None:
+        return
+    obj = event.object
+    util = getUtility(IIntIds, context=app)
+    obj_id = util.getId(obj)
+    catalogs = ICatalogs(app)
+    for entry in catalogs.values():
+        entry.catalog.index_doc(obj_id, obj)
+
+
+@adapter(IObjectModifiedEvent)
+def reindexDocSubscriber(event):
+    app = ISchoolToolApplication(None, None)
+    if app is None:
+        return
+    obj = event.object
+    util = queryUtility(IIntIds, context=app)
+    if util is None:
+        return
+    obj_id = util.queryId(obj)
+    if obj_id is None:
+        return
+    catalogs = ICatalogs(app)
+    for entry in catalogs.values():
+        entry.catalog.index_doc(obj_id, obj)
+
+
+@adapter(IIntIdRemovedEvent)
+def unindexDocSubscriber(event):
+    app = ISchoolToolApplication(None, None)
+    if app is None:
+        return
+    obj = event.object
+    util = getUtility(IIntIds, context=app)
+    obj_id = util.queryId(obj)
+    if obj_id is None:
+        return
+    catalogs = ICatalogs(app)
+    for entry in catalogs.values():
+        entry.catalog.unindex_doc(obj_id)

=== added file 'src/schooltool/app/catalog.zcml'
--- src/schooltool/app/catalog.zcml	1970-01-01 00:00:00 +0000
+++ src/schooltool/app/catalog.zcml	2010-05-28 11:09:37 +0000
@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<configure xmlns="http://namespaces.zope.org/zope">
+
+  <adapter factory=".catalog.getAppCatalogs" />
+
+  <subscriber
+      for="schooltool.app.interfaces.ICatalogStartUpEvent"
+      handler=".main.startSchoolToolCatalogs" />
+
+  <adapter
+      factory=".catalog.PrepareCatalogContainer"
+      name="prepare-catalog-container" />
+
+  <adapter
+      factory=".catalog.ExpiredCatalogCleanup"
+      name="expired-catalog-cleanup" />
+
+  <subscriber handler=".catalog.indexDocSubscriber" />
+  <subscriber handler=".catalog.reindexDocSubscriber" />
+  <subscriber handler=".catalog.unindexDocSubscriber" />
+
+</configure>

=== modified file 'src/schooltool/app/configure.zcml'
--- src/schooltool/app/configure.zcml	2010-01-19 16:41:42 +0000
+++ src/schooltool/app/configure.zcml	2010-05-28 11:09:37 +0000
@@ -169,6 +169,9 @@
       for="schooltool.app.interfaces.IApplicationStartUpEvent"
       handler=".main.startSchoolToolPlugins" />
 
+  <!-- Catalog support -->
+  <include file="catalog.zcml" />
+
   <!-- Timetables for content components -->
   <class class="schooltool.app.app.SchoolToolApplication">
     <implements interface="schooltool.timetable.interfaces.IHaveTimetables" />
@@ -185,7 +188,6 @@
   <class class="schooltool.resource.resource.BaseResource">
     <implements interface="schooltool.timetable.interfaces.IHaveTimetables" />
   </class>
-  
 
   <!-- Core and Domain content objects -->
 

=== modified file 'src/schooltool/app/interfaces.py'
--- src/schooltool/app/interfaces.py	2010-01-19 16:41:42 +0000
+++ src/schooltool/app/interfaces.py	2010-05-28 11:09:37 +0000
@@ -23,7 +23,9 @@
 import zope.schema
 
 from zope.component.interfaces import ObjectEvent, IObjectEvent
+from zope.container.interfaces import IContainer, IContained
 from zope.container.interfaces import IReadContainer
+from zope.container.constraints import contains
 from zope.interface import implements
 from zope.interface import Interface, Attribute
 from zope.location.interfaces import ILocation, IContained
@@ -72,15 +74,26 @@
 
 
 class ICatalogSetUpEvent(IObjectEvent):
-    """The SchoolTool catalogs are being initialized.
+    """Old style notification that the SchoolTool catalogs are being initialized.
 
-    Subscribers should set up their catalogs.
+    Subject to deprecation.  Subscribers should no longer use this to set up their
+    catalogs.
     """
 
 class CatalogSetUpEvent(ObjectEvent):
     implements(ICatalogSetUpEvent)
 
 
+class ICatalogStartUpEvent(IObjectEvent):
+    """The SchoolTool catalogs has started up.
+
+    A hook for catalog initialization.
+    """
+
+class CatalogStartUpEvent(ObjectEvent):
+    implements(ICatalogStartUpEvent)
+
+
 class ISchoolToolCalendar(IEditCalendar, ILocation):
     """A SchoolTool calendar.
 
@@ -234,6 +247,10 @@
         """Perform plugin specific set up."""
 
 
+class ICatalogStartUp(IPluginAction):
+    """Set up SchoolTool catalogs."""
+
+
 class IPluginInit(IPluginAction):
     """Perform plugin initialization when setting up the SchoolTool
     application."""
@@ -245,3 +262,24 @@
 
 class ISchoolToolAuthenticationPlugin(ISchoolToolAuthentication):
     """A plugin for local schooltool authentication utility. """
+
+
+class IVersionedCatalog(IContained):
+    """Versioned catalog entry."""
+
+    version = zope.schema.TextLine(
+        title=u"Version",
+        description=u"Current version of the catalog.")
+
+    expired = zope.schema.Bool(
+        title=u"Expired",
+        description=u"Expired catalogs should be removed.")
+
+    catalog = Attribute("""The catalog object.""")
+
+
+class ICatalogs(IContainer):
+    """Container of versioned catalogs."""
+
+    contains(IVersionedCatalog)
+

=== modified file 'src/schooltool/app/main.py'
--- src/schooltool/app/main.py	2010-04-28 21:27:43 +0000
+++ src/schooltool/app/main.py	2010-05-28 11:09:37 +0000
@@ -71,12 +71,14 @@
 from schooltool.app.interfaces import ApplicationStartUpEvent
 from schooltool.app.interfaces import ApplicationInitializationEvent
 from schooltool.app.interfaces import IPluginInit, IPluginStartUp
+from schooltool.app.interfaces import ICatalogStartUp
 from schooltool.app.interfaces import ISchoolToolInitializationUtility
 from schooltool.app.app import SchoolToolApplication
 from schooltool.app import pdf
 from schooltool.person.interfaces import IPersonFactory
 from schooltool.app.interfaces import ICookieLanguageSelector
 from schooltool.app.interfaces import CatalogSetUpEvent
+from schooltool.app.interfaces import CatalogStartUpEvent
 from schooltool.utility.utility import setUpUtilities
 from schooltool.utility.utility import UtilitySpecification
 
@@ -448,6 +450,12 @@
             print >> sys.stderr, "Failed to execute %s: %s" % (action, exception)
 
 
+def startSchoolToolCatalogs(event):
+    adapters = getAdapters((event.object, ), ICatalogStartUp)
+    sorter = PluginActionSorter(adapters)
+    executePluginActions(sorter())
+
+
 def initializeSchoolToolPlugins(event):
     adapters = getAdapters((event.object, ), IPluginInit)
     sorter = PluginActionSorter(adapters)
@@ -617,6 +625,7 @@
             # before initializing plugins themselves or else all the
             # initial groups, persons, resources will not get indexed
             notify(CatalogSetUpEvent(app))
+            notify(CatalogStartUpEvent(app))
 
             # initialize plugins themselves
             notify(ApplicationInitializationEvent(app))
@@ -715,7 +724,10 @@
         connection = db.open()
         root = connection.root()
         app = root[ZopePublication.root_name]
+        setSite(app)
+        notify(CatalogStartUpEvent(app))
         notify(ApplicationStartUpEvent(app))
+        setSite(None)
         transaction.commit()
         connection.close()
 

=== modified file 'src/schooltool/app/security.py'
--- src/schooltool/app/security.py	2010-02-09 16:54:13 +0000
+++ src/schooltool/app/security.py	2010-05-28 11:09:37 +0000
@@ -40,7 +40,8 @@
 from zope.site import LocalSiteManager
 from zope.traversing.browser.absoluteurl import absoluteURL
 from zope.traversing.api import traverse
-from schooltool.app.app import getSchoolToolApplication
+
+from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.interfaces import ISchoolToolAuthentication
 from schooltool.app.interfaces import IAsset
 from schooltool.person.interfaces import IPerson
@@ -95,13 +96,13 @@
                 return self.getPrincipal('sb.person.' + login)
 
     def _checkPlainTextPassword(self, username, password):
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         if username in app['persons']:
             person = app['persons'][username]
             return person.checkPassword(password)
 
     def _checkHashedPassword(self, username, password):
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         if username in app['persons']:
             person = app['persons'][username]
             return (person._hashed_password is not None
@@ -139,7 +140,7 @@
 
     def unauthorized(self, id, request):
         """Signal an authorization failure."""
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         app_url = absoluteURL(app, request)
         query_string = request.getHeader('QUERY_STRING')
         post_form_id = self.storePOSTData(request)
@@ -162,7 +163,7 @@
 
         Returns principals for groups and persons.
         """
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         if id.startswith(self.person_prefix):
             username = id[len(self.person_prefix):]
             if username in app['persons']:
@@ -331,7 +332,7 @@
         prefix = PersonContainerAuthenticationPlugin.group_prefix
         if not group_principal_id.startswith(prefix):
             return None
-        groups = IGroupContainer(getSchoolToolApplication(), None)
+        groups = IGroupContainer(ISchoolToolApplication(None), None)
         if groups is None:
             return None
         group_id = group_principal_id[len(prefix):]

=== modified file 'src/schooltool/app/security.txt'
--- src/schooltool/app/security.txt	2010-02-09 16:54:13 +0000
+++ src/schooltool/app/security.txt	2010-05-28 11:09:37 +0000
@@ -66,9 +66,12 @@
     >>> verifyObject(ISite, app)
     Traceback (most recent call last):
     ...
-    DoesNotImplement: ...
-    ...
+    DoesNotImplement: An object does not implement interface
+                      <InterfaceClass zope.component.interfaces.ISite>
 
+    >>> from zope.component import provideAdapter
+    >>> from schooltool.app.app import getSchoolToolApplication
+    >>> provideAdapter(getSchoolToolApplication)
 
 The SchoolToolAuthenticationUtility is an IAuthentication utility that
 lives in that site:

=== added file 'src/schooltool/app/tests/catalog-integration.txt'
--- src/schooltool/app/tests/catalog-integration.txt	1970-01-01 00:00:00 +0000
+++ src/schooltool/app/tests/catalog-integration.txt	2010-05-28 11:09:37 +0000
@@ -0,0 +1,105 @@
+Version-controlled catalogs
+===========================
+
+  A Catalog in it's essence is a set of value caches (indexes).
+Usually these are cached attributes of objects in a container or
+objects implementing a given interface.  Sometimes aggregated values
+like persons full title are cached.
+
+  The main purpose of catalogs is giving access to the values without
+the need to load the whole object into memory.  Think searching persons
+named 'M...' in a container with several thousands of them, you'll get
+the picture.
+
+  Due to their nature, catalogs need to be rebuilt, changed,
+reindexed, etc. during active development.  They are commonly stored
+in the database - that would mean evolution scripts.
+
+  For the above reasons, SchoolTool provides catalog version control
+and catalog cache that gets updated when catalog versions change.
+
+
+How it works
+------------
+
+  To register a versioned catalog, let's first inherit the CatalogFactory and
+implement the required methods:
+
+    >>> from schooltool.app.catalog import CatalogFactory
+
+    >>> class MyCatalog(CatalogFactory):
+    ...     version = 1
+    ...     def createCatalog(self):
+    ...         return CatalogStub('my catalog')
+    ...     def setIndexes(self, catalog):
+    ...         print 'Setting indexes for', catalog
+
+  Catalogs are registered as named adapters.
+
+    >>> provideAdapter(
+    ...     MyCatalog, name="test-catalog-integration-mycatalog")
+
+  Sometime at server start up catalog setup event is fired and
+catalogs get created.
+
+    >>> from schooltool.app.interfaces import ISchoolToolApplication
+    >>> from schooltool.app.interfaces import CatalogStartUpEvent
+    >>> from zope.event import notify
+
+    >>> print MyCatalog.get()
+    None
+
+    >>> notify(CatalogStartUpEvent(ISchoolToolApplication(None)))
+    Setting indexes for <CatalogStub 'my catalog'>
+
+    >>> catalog = MyCatalog.get()
+    >>> print catalog
+    <CatalogStub 'my catalog'>
+
+  Catalog's __parent__ holds the versioning information.
+
+    >>> print catalog.__parent__
+    <VersionedCatalog v. u'1'>: <CatalogStub 'my catalog'>
+
+  The catalog's unique name is constructed from the factory class
+name.  So if you rename the class, know that the catalogs will be
+re-created and re-indexed.
+
+    >>> from schooltool.app.interfaces import ICatalogs
+    >>> print sorted(ICatalogs(ISchoolToolApplication(None)))
+    [u'catalog:__builtin__.MyCatalog']
+
+  Next time the server starts up, catalog is left as it is.  We'll
+demonstrate this by changing the catalog creation method, but leaving
+the version unchanged.
+
+    >>> MyCatalog.createCatalog = lambda self: CatalogStub('my better catalog')
+    >>> notify(CatalogStartUpEvent(ISchoolToolApplication(None)))
+
+    >>> print MyCatalog.get()
+    <CatalogStub 'my catalog'>
+
+  But once we change the version, the catalog gets re-created.
+
+    >>> MyCatalog.version = 1.1
+
+    >>> notify(CatalogStartUpEvent(ISchoolToolApplication(None)))
+    Setting indexes for <CatalogStub 'my better catalog'>
+
+    >>> catalog = MyCatalog.get()
+    >>> print catalog.__parent__
+    <VersionedCatalog v. u'1.1'>: <CatalogStub 'my better catalog'>
+
+  And of course once the catalog factory is no longer provided, catalog
+will be deleted.
+
+    >>> unregisterAdapter(
+    ...     MyCatalog, name="test-catalog-integration-mycatalog")
+
+    >>> notify(CatalogStartUpEvent(ISchoolToolApplication(None)))
+
+    >>> print MyCatalog.get()
+    None
+
+    >>> print sorted(ICatalogs(ISchoolToolApplication(None)))
+    []

=== modified file 'src/schooltool/app/tests/test_app.py'
--- src/schooltool/app/tests/test_app.py	2010-02-09 19:18:22 +0000
+++ src/schooltool/app/tests/test_app.py	2010-05-28 11:09:37 +0000
@@ -107,13 +107,11 @@
       >>> from zope.site import LocalSiteManager
       >>> app.setSiteManager(LocalSiteManager(app))
 
-    If site is not a SchoolToolApplication, we get an error
+    If site is not a SchoolToolApplication, we get None
 
       >>> from schooltool.app.app import getSchoolToolApplication
-      >>> getSchoolToolApplication()
-      Traceback (most recent call last):
-      ...
-      ValueError: can't get a SchoolToolApplication
+      >>> print getSchoolToolApplication()
+      None
 
     If current site is a SchoolToolApplication, we get it:
 

=== added file 'src/schooltool/app/tests/test_catalog.py'
--- src/schooltool/app/tests/test_catalog.py	1970-01-01 00:00:00 +0000
+++ src/schooltool/app/tests/test_catalog.py	2010-05-28 11:09:37 +0000
@@ -0,0 +1,749 @@
+#
+# SchoolTool - common information systems platform for school administration
+# Copyright (c) 2010 Shuttleworth Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+"""
+Unit tests for catalogs
+"""
+import unittest
+import doctest
+
+from zope.app.testing import setup
+from zope.interface import implements, Interface
+from zope.interface.verify import verifyObject
+from zope.component import provideAdapter
+from zope.component.hooks import getSite, setSite
+from zope.site import SiteManagerContainer
+from zope.site.folder import rootFolder
+
+from schooltool.testing.setup import ZCMLWrapper
+from schooltool.app.interfaces import ISchoolToolApplication
+from schooltool.app.interfaces import ICatalogs
+from schooltool.app.catalog import getAppCatalogs
+
+
+class AppStub(dict, SiteManagerContainer):
+    implements(ISchoolToolApplication)
+
+
+class CatalogStub(dict):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return '<%s %r>' % (self.__class__.__name__, self.name)
+
+
+def provideApplicationStub():
+    app = AppStub()
+    provideAdapter(
+        lambda ignored: app,
+        adapts=(None,),
+        provides=ISchoolToolApplication)
+    return app
+
+
+def doctest_Catalogs():
+    """Tests for Catalogs.
+
+        >>> app = provideApplicationStub()
+
+    There is an adapter that sets up and returns the catalogs container for the app.
+
+        >>> list(app.items())
+        []
+
+        >>> catalogs = ICatalogs(app)
+
+        >>> list(app.items())
+        [('schooltool.app.catalog:Catalogs',
+          <schooltool.app.catalog.Catalogs object at ...>)]
+
+        >>> verifyObject(ICatalogs, catalogs)
+        True
+
+        >>> catalogs is app.values()[0]
+        True
+
+    Catalogs is a dict-like container.
+
+        >>> print dict(catalogs)
+        {}
+
+    """
+
+
+def doctest_PrepareCatalogContainer():
+    """Tests for PrepareCatalogContainer.
+
+        >>> class VersionedCatalogStub(object):
+        ...     def __init__(self, expired=False):
+        ...         self.expired = expired
+        ...     def __repr__(self):
+        ...         return '<Stub expired=%s>' % self.expired
+
+    Let's build an app with some catalog entries.
+
+        >>> app = provideApplicationStub()
+        >>> catalogs = ICatalogs(app)
+
+        >>> catalogs['cat-1'] = VersionedCatalogStub(expired=False)
+        >>> catalogs['cat-2'] = VersionedCatalogStub(expired=True)
+        >>> catalogs['cat-3'] = VersionedCatalogStub(expired=False)
+
+    PrepareCatalogContainer is supposed to be executed as the first action
+    of application catalog startup.
+
+        >>> from schooltool.app.interfaces import ICatalogStartUp
+        >>> from schooltool.app.catalog import PrepareCatalogContainer
+
+        >>> action = PrepareCatalogContainer(app)
+        >>> verifyObject(ICatalogStartUp, action)
+        True
+
+    When executed it marks all catalogs expired.
+
+        >>> action()
+
+        >>> print sorted(ICatalogs(app).items())
+        [(u'cat-1', <Stub expired=True>),
+         (u'cat-2', <Stub expired=True>),
+         (u'cat-3', <Stub expired=True>)]
+
+    """
+
+
+def doctest_ExpiredCatalogCleanup():
+    """Tests for ExpiredCatalogCleanup.
+
+        >>> class VersionedCatalogStub(object):
+        ...     def __init__(self, expired=False):
+        ...         self.expired = expired
+        ...     def __repr__(self):
+        ...         return '<Stub expired=%s>' % self.expired
+
+    Let's build an app with some catalog entries.
+
+        >>> app = provideApplicationStub()
+        >>> catalogs = ICatalogs(app)
+
+        >>> catalogs['cat-1'] = VersionedCatalogStub(expired=False)
+        >>> catalogs['cat-2'] = VersionedCatalogStub(expired=True)
+        >>> catalogs['cat-3'] = VersionedCatalogStub(expired=False)
+
+    ExpiredCatalogCleanup is supposed to be executed as the last action
+    of application catalog startup.
+
+        >>> from schooltool.app.interfaces import ICatalogStartUp
+        >>> from schooltool.app.catalog import ExpiredCatalogCleanup
+
+        >>> action = ExpiredCatalogCleanup(app)
+        >>> verifyObject(ICatalogStartUp, action)
+        True
+
+    When executed it removes expired catalogs.
+
+        >>> action()
+
+        >>> print sorted(ICatalogs(app).items())
+        [(u'cat-1', <Stub expired=False>),
+         (u'cat-3', <Stub expired=False>)]
+
+    """
+
+
+def doctest_CatalogFactory():
+    """Tests for CatalogFactory.
+
+        >>> app = provideApplicationStub()
+
+    CatalogFactory is a base class for creating and registering versioned catalogs.
+
+        >>> from schooltool.app.catalog import CatalogFactory
+        >>> factory = CatalogFactory(app)
+
+        >>> factory.createCatalog()
+        Traceback (most recent call last):
+        ...
+        NotImplementedError
+
+        >>> factory.setIndexes(None)
+        Traceback (most recent call last):
+        ...
+        NotImplementedError
+
+    It is also an action to be executed on application catalog startup.
+
+        >>> from schooltool.app.interfaces import ICatalogStartUp
+
+        >>> class CatalogFactoryForTest(CatalogFactory):
+        ...    version = 1
+        ...    def createCatalog(self):
+        ...        return CatalogStub('test')
+        ...    def setIndexes(self, catalog):
+        ...        catalog['idx-1'] = 'Stub index 1'
+
+        >>> factory = CatalogFactoryForTest(app)
+
+        >>> verifyObject(ICatalogStartUp, factory)
+        True
+
+    It defines some control on when it wants to be executed.
+
+        >>> factory.after
+        ('prepare-catalog-container',)
+
+        >>> factory.before
+        ('expired-catalog-cleanup',)
+
+    The class itself has some helpers to fetch the catalog from app.
+
+        >>> print CatalogFactoryForTest.key()
+        catalog:schooltool.app.tests.test_catalog.CatalogFactoryForTest
+
+        >>> print CatalogFactoryForTest.get()
+        None
+
+    Well, the catalog was not set up yet.  Let's build it.
+
+        >>> from schooltool.app.interfaces import IVersionedCatalog
+
+        >>> factory()
+
+        >>> catalog = CatalogFactoryForTest.get()
+
+        >>> print catalog
+        <CatalogStub 'test'>
+
+        >>> sorted(catalog.items())
+        [('idx-1', 'Stub index 1')]
+
+    Both catalog and it's version entry are stored in app's catalog container.
+
+        >>> version_entry = catalog.__parent__
+
+        >>> print version_entry
+        <VersionedCatalog v. u'1'>: <CatalogStub 'test'>
+
+        >>> verifyObject(IVersionedCatalog, version_entry)
+        True
+
+        >>> print version_entry.__parent__
+        <schooltool.app.catalog.Catalogs object at ...>
+
+        >>> version_entry.__parent__ is ICatalogs(app)
+        True
+
+        >>> print version_entry.__name__
+        catalog:schooltool.app.tests.test_catalog.CatalogFactoryForTest
+
+        >>> print version_entry.__name__ == CatalogFactoryForTest.key()
+        True
+
+    """
+
+
+def doctest_CatalogFactory_versioning():
+    """Tests for CatalogFactory handling of catalog versions.
+
+        >>> class CatalogCreatorMixin(object):
+        ...    def createCatalog(self):
+        ...        return CatalogStub('test-1')
+        ...    def setIndexes(self, catalog):
+        ...        catalog['idx-1'] = 'Stub index 1'
+
+        >>> app = provideApplicationStub()
+        >>> catalogs = ICatalogs(app)
+
+    Let's create a catalog first.
+
+        >>> from schooltool.app.catalog import CatalogFactory
+        >>> class Factory1(CatalogCreatorMixin, CatalogFactory):
+        ...    version = 1
+
+        >>> factory1 = Factory1(app)
+
+        >>> factory1()
+        >>> catalog1 = Factory1.get()
+
+        >>> print catalog1
+        <CatalogStub 'test-1'>
+
+        >>> print sorted(catalogs.keys())
+        [u'catalog:schooltool.app.tests.test_catalog.Factory1']
+
+    If the version stays the same, factory leaves the catalog untouched, but
+    changes it's expired status.
+
+        >>> class Factory1(CatalogCreatorMixin, CatalogFactory):
+        ...    version = 1
+
+        >>> catalog1.__parent__.expired = True
+
+        >>> factory1 = Factory1(app)
+        >>> factory1()
+
+        >>> Factory1.get() is catalog1
+        True
+
+        >>> catalog1.__parent__.expired
+        False
+
+        >>> print sorted(catalogs.keys())
+        [u'catalog:schooltool.app.tests.test_catalog.Factory1']
+
+    If we changed the version, catalog gets re-created.
+
+        >>> class Factory1(CatalogCreatorMixin, CatalogFactory):
+        ...    version = 1.2
+        ...    def setIndexes(self, catalog):
+        ...        catalog['idx-1'] = 'Stub index 1 point 2'
+
+        >>> factory12 = Factory1(app)
+        >>> factory12()
+
+        >>> catalog12 = Factory1.get()
+        >>> catalog12 is catalog1
+        False
+
+        >>> print sorted(catalog12.items())
+        [('idx-1', 'Stub index 1 point 2')]
+
+    CatalogFactory actually uses the getVersion method, not the version
+    attribute.  Let's override getVersion
+
+        >>> class Factory1(CatalogCreatorMixin, CatalogFactory):
+        ...    version = 1.2
+        ...    def getVersion(self):
+        ...        return 'stable-version'
+
+        >>> factory = Factory1(app)
+        >>> factory()
+
+        >>> catalog_stable = Factory1.get()
+
+        >>> catalog_stable is catalog12
+        False
+
+        >>> print Factory1.get().__parent__
+        <VersionedCatalog v. 'stable-version'>: <CatalogStub 'test-1'>
+
+        >>> class Factory1(CatalogCreatorMixin, CatalogFactory):
+        ...    version = 1.314
+        ...    def getVersion(self):
+        ...        return 'stable-version'
+
+        >>> factory1 = Factory1(app)
+        >>> factory1()
+
+        >>> Factory1.get() is catalog_stable
+        True
+
+    """
+
+
+def doctest_CatalogImplementing():
+    """Tests for CatalogImplementing.  This is a factory of catalogs that
+    contain only objects implementing given interface.
+
+    Say we have two objects implementing very similar interfaces.
+
+        >>> from zope.schema import TextLine
+
+        >>> class TitledObject(object):
+        ...    def __init__(self, title):
+        ...        self.title = title
+        ...    def __repr__(self):
+        ...        return '<%s (%r)>' % (self.__class__.__name__, self.title)
+
+        >>> class IFoo(Interface):
+        ...     title = TextLine(title=u"Title")
+        >>> class Foo(TitledObject):
+        ...     implements(IFoo)
+
+        >>> class IBar(Interface):
+        ...     title = TextLine(title=u"Title")
+        >>> class Bar(TitledObject):
+        ...     implements(IBar)
+
+        >>> app = provideApplicationStub()
+        >>> app['objects'] = {
+        ...     1: Foo('one'),
+        ...     2: Bar('two'),
+        ...     3: Foo('three'),
+        ...     }
+
+    Let's create a catalog that indexes titles of IFoo.
+
+        >>> from zope.container.contained import Contained
+        >>> from schooltool.app.catalog import CatalogImplementing
+
+        >>> class TitleIndex(Contained):
+        ...     def __init__(self):
+        ...         self.data = []
+        ...     def index_doc(self, id, value):
+        ...         self.data.append((id, value))
+
+        >>> class CatalogTitles(CatalogImplementing):
+        ...    version = 1
+        ...    interface = IFoo
+        ...    def setIndexes(self, catalog):
+        ...        catalog['title'] = TitleIndex()
+
+        >>> factory = CatalogTitles(app)
+        >>> factory()
+
+        >>> catalog = CatalogTitles.get()
+        >>> print catalog.__parent__
+        <VersionedCatalog v.
+            u'interface:schooltool.app.tests.test_catalog.IFoo,
+              version:1'>:
+        <zc.catalog.extentcatalog.Catalog object at ...>
+
+    This catalog only indexes objects implementing IFoo.
+
+        >>> def index_app(catalog):
+        ...     for docid, doc in app['objects'].items():
+        ...         catalog.index_doc(docid, doc)
+        ...     print sorted(catalog['title'].data)
+
+        >>> index_app(CatalogTitles.get())
+        [(1, <Foo ('one')>), (3, <Foo ('three')>)]
+
+    Catalog indexes are untouched after app restart.
+
+        >>> factory = CatalogTitles(app)
+        >>> factory()
+
+        >>> CatalogTitles.get() is catalog
+        True
+
+        >>> print sorted(CatalogTitles.get()['title'].data)
+        [(1, <Foo ('one')>), (3, <Foo ('three')>)]
+
+    If we change the version, catalog will be re-created, as expected.
+
+        >>> class CatalogTitles(CatalogImplementing):
+        ...    version = 2
+        ...    interface = IFoo
+        ...    def setIndexes(self, catalog):
+        ...        catalog['title'] = TitleIndex()
+
+        >>> factory = CatalogTitles(app)
+        >>> factory()
+
+        >>> catalog2 = CatalogTitles.get()
+        >>> catalog2 is catalog
+        False
+
+    We trust other machinery to reindex the catalog.
+
+        >>> print sorted(CatalogTitles.get()['title'].data)
+        []
+
+    If we change the interface, catalog also gets re-created.
+
+        >>> index_app(CatalogTitles.get())
+        [(1, <Foo ('one')>), (3, <Foo ('three')>)]
+
+        >>> class CatalogTitles(CatalogImplementing):
+        ...    version = 2
+        ...    interface = IBar
+        ...    def setIndexes(self, catalog):
+        ...        catalog['title'] = TitleIndex()
+
+        >>> factory = CatalogTitles(app)
+        >>> factory()
+
+        >>> CatalogTitles.get() is catalog2
+        False
+
+        >>> index_app(CatalogTitles.get())
+        [(2, <Bar ('two')>)]
+
+        >>> catalog3 = CatalogTitles.get()
+        >>> print catalog3.__parent__
+        <VersionedCatalog v.
+            u'interface:schooltool.app.tests.test_catalog.IBar,
+              version:2'>:
+        <zc.catalog.extentcatalog.Catalog object at ...>
+
+    """
+
+
+def doctest_AttributeCatalog():
+    """Tests for AttributeCatalog.  This is a factory of catalogs that
+    index attributes of objects implementing given interface.
+
+    Say we have an object we want to catalog.
+
+        >>> from zope.schema import TextLine
+
+        >>> class ITriplet(Interface):
+        ...     a = TextLine(title=u"Title")
+        ...     b = TextLine(title=u"Title")
+        ...     c = TextLine(title=u"Title")
+        >>> class Triplet(object):
+        ...     implements(ITriplet)
+        ...     def __init__(self, a, b, c):
+        ...         self.a, self.b, self.c = a, b, c
+        ...     def __repr__(self):
+        ...         return '<%s (%s:%s:%s)>' % (
+        ...             self.__class__.__name__,
+        ...             self.a, self.b, self.c)
+
+        >>> class Foo(object):
+        ...     implements(Interface)
+        ...     a = b = c = 0
+
+        >>> app = provideApplicationStub()
+        >>> app['objects'] = {
+        ...     0: Foo(),
+        ...     1: Triplet('one', 'eins', 'I'),
+        ...     2: Triplet('two', 'zwei', 'II'),
+        ...     3: Triplet('three', 'drei', 'III'),
+        ...     }
+
+    Let's create a catalog that indexes few attributes of the triplet.
+
+        >>> from schooltool.app.catalog import AttributeCatalog
+
+        >>> class CatalogTriplets(AttributeCatalog):
+        ...    version = 1
+        ...    interface = ITriplet
+        ...    attributes = ('a', 'c')
+
+        >>> factory = CatalogTriplets(app)
+        >>> factory()
+
+    And index some objects.
+
+        >>> def index_app(catalog):
+        ...     for docid, doc in app['objects'].items():
+        ...         catalog.index_doc(docid, doc)
+        ...     for name, index in catalog.items():
+        ...         print 'catalog[%r]: %s' % (
+        ...             name,
+        ...             sorted(index.documents_to_values.items()))
+
+        >>> index_app(CatalogTriplets.get())
+        catalog[u'a']: [(1, 'one'), (2, 'two'), (3, 'three')]
+        catalog[u'c']: [(1, 'I'), (2, 'II'), (3, 'III')]
+
+    We can see that version of the catalog also includes the list of attributes,
+    so the catalog will be recreated when attributes, interface or version changes.
+
+        >>> catalog = CatalogTriplets.get()
+        >>> print catalog.__parent__
+        <VersionedCatalog v.
+            u"attributes:('a', 'c'),
+              interface:schooltool.app.tests.test_catalog.ITriplet,
+              version:1">:
+        <zc.catalog.extentcatalog.Catalog object at ...>
+
+        >>> class CatalogTriplets(AttributeCatalog):
+        ...    version = 1
+        ...    interface = ITriplet
+        ...    attributes = ('b')
+
+        >>> factory = CatalogTriplets(app)
+        >>> factory()
+
+        >>> CatalogTriplets.get() is catalog
+        False
+
+        >>> index_app(CatalogTriplets.get())
+        catalog[u'b']: [(1, 'eins'), (2, 'zwei'), (3, 'drei')]
+
+    """
+
+
+def doctest_catalog_subscribers():
+    """Tests for catalog subscribers.
+
+    Let's provide our subscribers.
+
+        >>> from zope.component import provideHandler
+        >>> from schooltool.app.catalog import indexDocSubscriber
+        >>> from schooltool.app.catalog import reindexDocSubscriber
+        >>> from schooltool.app.catalog import unindexDocSubscriber
+
+        >>> provideHandler(indexDocSubscriber)
+        >>> provideHandler(reindexDocSubscriber)
+        >>> provideHandler(unindexDocSubscriber)
+
+    And set up the event firing helpers.
+
+        >>> from zope.component import provideUtility, queryUtility
+        >>> from zope.event import notify
+        >>> from zope.intid.interfaces import (
+        ...     IIntIds, IntIdAddedEvent, IntIdRemovedEvent)
+        >>> from zope.lifecycleevent import (
+        ...     ObjectAddedEvent, ObjectRemovedEvent, ObjectModifiedEvent)
+
+        >>> def addAndNotify(obj, obj_id):
+        ...     util = queryUtility(IIntIds)
+        ...     if util is None:
+        ...         print "No IIntIds utility, so don't fire IntIdAddedEvent"
+        ...         return
+        ...     util[obj] = obj_id
+        ...     print 'firing IntIdAddedEvent'
+        ...     notify(IntIdAddedEvent(obj, ObjectAddedEvent(obj)))
+
+        >>> def notifyModified(obj):
+        ...     print 'firing ObjectModifiedEvent'
+        ...     notify(ObjectModifiedEvent(obj))
+
+        >>> def notifyAndRemove(obj):
+        ...     util = queryUtility(IIntIds)
+        ...     if util is None:
+        ...         print "No IIntIds utility, so don't fire IntIdRemovedEvent"
+        ...         return
+        ...     print 'firing IntIdRemovedEvent'
+        ...     notify(IntIdRemovedEvent(obj, ObjectAddedEvent(obj)))
+        ...     del util[obj]
+
+    When database is being set up, we may have no SchoolToolApplication and
+    no IntIds utility.
+
+        >>> class TestObj(object):
+        ...     __parent__ = __name__ = None
+        ...     def __init__(self, name):
+        ...         self.name = name
+        ...     def __repr__(self):
+        ...         return '<%s %r>' % (self.__class__.__name__, self.name)
+
+        >>> test_one = TestObj('missing_one')
+        >>> addAndNotify(test_one, 1)
+        No IIntIds utility, so don't fire IntIdAddedEvent
+
+        >>> notifyModified(test_one)
+        firing ObjectModifiedEvent
+
+        >>> notifyAndRemove(test_one)
+        No IIntIds utility, so don't fire IntIdRemovedEvent
+
+    Having IntIds utility is not enough as catalogs live within the application
+    itself.  Subscribers handle this case also.
+
+        >>> class IntIdsStub(dict):
+        ...     def getId(self, obj):
+        ...         return self[obj]
+        ...     def queryId(self, obj):
+        ...         return self.get(obj)
+
+        >>> provideUtility(IntIdsStub(), IIntIds)
+
+        >>> test_two = TestObj('two')
+        >>> addAndNotify(test_two, 2)
+        firing IntIdAddedEvent
+
+        >>> notifyModified(test_two)
+        firing ObjectModifiedEvent
+
+        >>> notifyAndRemove(test_two)
+        firing IntIdRemovedEvent
+
+    Let's provide an application and set up a catalog.
+
+        >>> from schooltool.app.catalog import VersionedCatalog
+
+        >>> class PrintingCatalogStub(CatalogStub):
+        ...      def index_doc(self, doc_id, doc):
+        ...          print 'CatalogStub(%r) indexed doc %s (%s)' % (
+        ...              self.name, doc_id, doc)
+        ...      def unindex_doc(self, doc_id):
+        ...          print 'CatalogStub(%r) unindexed doc %s' % (
+        ...              self.name, doc_id)
+
+        >>> app = provideApplicationStub()
+        >>> catalogs = ICatalogs(app)
+        >>> catalogs['demo'] = VersionedCatalog(PrintingCatalogStub('demo'), 'v1')
+
+    We can now see objects being indexed.
+
+        >>> test_three = TestObj('three')
+        >>> addAndNotify(test_three, 3)
+        firing IntIdAddedEvent
+        CatalogStub('demo') indexed doc 3 (<TestObj 'three'>)
+
+        >>> test_three.name='three and a half'
+        >>> notifyModified(test_three)
+        firing ObjectModifiedEvent
+        CatalogStub('demo') indexed doc 3 (<TestObj 'three and a half'>)
+
+        >>> notifyAndRemove(test_three)
+        firing IntIdRemovedEvent
+        CatalogStub('demo') unindexed doc 3
+
+    """
+
+
+def setUp(test):
+    setup.placefulSetUp()
+    provideAdapter(getAppCatalogs)
+
+
+def tearDown(test):
+    setup.placefulTearDown()
+
+
+def provideStubAdapter(factory, adapts=None, provides=None, name=u''):
+    sm = getSite().getSiteManager()
+    sm.registerAdapter(factory, required=adapts, provided=provides, name=name)
+
+
+def unregisterStubAdapter(factory, adapts=None, provides=None, name=u''):
+    sm = getSite().getSiteManager()
+    sm.unregisterAdapter(factory, required=adapts, provided=provides, name=name)
+
+
+def setUpIntegration(test):
+    setup.placefulSetUp()
+    zcml = ZCMLWrapper()
+    zcml.setUp(
+        namespaces={"": "http://namespaces.zope.org/zope"},
+        i18n_domain='schooltool')
+    zcml.include('zope.app.zcmlfiles')
+    zcml.include('schooltool.app', file='catalog.zcml')
+    root = rootFolder()
+    root['app'] = provideApplicationStub()
+    setup.createSiteManager(root['app'], setsite=True)
+    test.globs.update({
+        'zcml': zcml,
+        'CatalogStub': CatalogStub,
+        'provideAdapter': provideStubAdapter,
+        'unregisterAdapter': unregisterStubAdapter,
+        })
+
+
+def test_suite():
+    optionflags = (doctest.NORMALIZE_WHITESPACE |
+                   doctest.ELLIPSIS |
+                   doctest.REPORT_NDIFF)
+    return unittest.TestSuite([
+        doctest.DocTestSuite(setUp=setUp, tearDown=tearDown,
+                             optionflags=optionflags),
+        doctest.DocFileSuite(
+            'catalog-integration.txt',
+            setUp=setUpIntegration, tearDown=tearDown,
+            optionflags=optionflags),
+           ])
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='test_suite')

=== modified file 'src/schooltool/app/tests/test_security.py'
--- src/schooltool/app/tests/test_security.py	2010-01-21 17:31:17 +0000
+++ src/schooltool/app/tests/test_security.py	2010-05-28 11:09:37 +0000
@@ -65,10 +65,13 @@
 
 
 def test_suite():
+    optionflags = (doctest.ELLIPSIS |
+                   doctest.NORMALIZE_WHITESPACE |
+                   doctest.REPORT_NDIFF)
     return unittest.TestSuite([
         unittest.makeSuite(TestAuthSetUpSubscriber),
-        doctest.DocTestSuite(optionflags=doctest.ELLIPSIS),
-        doctest.DocFileSuite('../security.txt', optionflags=doctest.ELLIPSIS),
+        doctest.DocTestSuite(optionflags=optionflags),
+        doctest.DocFileSuite('../security.txt', optionflags=optionflags),
         ])
 
 

=== modified file 'src/schooltool/basicperson/configure.zcml'
--- src/schooltool/basicperson/configure.zcml	2009-11-02 13:45:40 +0000
+++ src/schooltool/basicperson/configure.zcml	2010-05-28 11:09:37 +0000
@@ -64,11 +64,6 @@
      provides="schooltool.app.interfaces.ICalendarParentCrowd"
      name="schooltool.view" />
 
-  <subscriber
-     for="schooltool.app.interfaces.ICatalogSetUpEvent"
-     handler=".person.catalogSetUpSubscriber"
-     />
-
   <utility
      factory=".vocabularies.groupVocabularyFactory"
      provides="zope.schema.interfaces.IVocabularyFactory"

=== modified file 'src/schooltool/basicperson/overrides.zcml'
--- src/schooltool/basicperson/overrides.zcml	2009-12-23 20:59:28 +0000
+++ src/schooltool/basicperson/overrides.zcml	2010-05-28 11:09:37 +0000
@@ -10,9 +10,12 @@
       name="person_info_viewers"
       factory=".security.PersonInfoViewersCrowd" />
 
+  <adapter factory=".person.PersonCatalog"
+           name="schooltool.person.person.PersonCatalog" />
+
   <adapter
       for="schooltool.person.interfaces.IPersonContainer"
-      factory=".person.getPersonContainerCatalog"
+      factory=".person.getPersonCatalog"
       provides="zope.catalog.interfaces.ICatalog" />
 
   <configure

=== modified file 'src/schooltool/basicperson/person.py'
--- src/schooltool/basicperson/person.py	2009-12-23 20:59:28 +0000
+++ src/schooltool/basicperson/person.py	2010-05-28 11:09:37 +0000
@@ -21,11 +21,6 @@
 """
 from zope.interface import implements
 from zope.component import adapts
-from zope.catalog.interfaces import ICatalog
-from zope.catalog.catalog import Catalog
-from zope.component import getUtility
-
-from zc.catalog.catalogindex import ValueIndex
 
 from schooltool.person.person import Person
 from schooltool.person.interfaces import IPersonFactory
@@ -37,12 +32,10 @@
 from schooltool.relationship import RelationshipProperty
 from schooltool.basicperson.advisor import URIAdvisor, URIAdvising, URIStudent
 from schooltool.basicperson.interfaces import IBasicPerson
+from schooltool.app.catalog import AttributeCatalog
 from schooltool.common import SchoolToolMessage as _
 
 
-PERSON_CATALOG_KEY = 'schooltool.basicperson'
-
-
 class BasicPerson(Person):
     implements(IBasicPerson)
 
@@ -119,16 +112,11 @@
                 PersonInstructorsCrowd(self.context).contains(principal))
 
 
-def catalogSetUp(catalog):
-    catalog['__name__'] = ValueIndex('__name__', IBasicPerson)
-    catalog['title'] = ValueIndex('title', IBasicPerson)
-    catalog['first_name'] = ValueIndex('first_name', IBasicPerson)
-    catalog['last_name'] = ValueIndex('last_name', IBasicPerson)
-
-
-catalogSetUpSubscriber = UtilitySetUp(
-    Catalog, ICatalog, PERSON_CATALOG_KEY, setUp=catalogSetUp)
-
-
-def getPersonContainerCatalog(container):
-    return getUtility(ICatalog, PERSON_CATALOG_KEY)
+class PersonCatalog(AttributeCatalog):
+
+    version = '1 - replaced catalog utility'
+    interface = IBasicPerson
+    attributes = ('__name__', 'title', 'first_name', 'last_name')
+
+
+getPersonCatalog = PersonCatalog.get

=== modified file 'src/schooltool/commendation/browser.py'
--- src/schooltool/commendation/browser.py	2010-04-28 23:13:27 +0000
+++ src/schooltool/commendation/browser.py	2010-05-28 11:09:37 +0000
@@ -32,6 +32,7 @@
 from schooltool.commendation import interfaces, commendation
 from schooltool.commendation.interfaces import _
 from schooltool.app import app
+from schooltool.app.interfaces import ISchoolToolApplication
 
 
 # This is a simple view class that provides the information of a commendation
@@ -164,7 +165,7 @@
             self.request.get('search_scope', 'group')]
 
         # Get the SchoolTool application instance and access its annotations.
-        stapp = app.getSchoolToolApplication()
+        stapp = ISchoolToolApplication(None)
         annotations = IAnnotations(stapp)
         # A list comprehension that iterates through all the commendations and
         # applies the filter one-by-one.

=== modified file 'src/schooltool/commendation/commendation.py'
--- src/schooltool/commendation/commendation.py	2010-04-28 23:13:27 +0000
+++ src/schooltool/commendation/commendation.py	2010-05-28 11:09:37 +0000
@@ -30,6 +30,7 @@
 from zope.security.management import queryInteraction
 
 from schooltool.app import app
+from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.commendation.interfaces import ICommendation
 from schooltool.commendation.interfaces import ICommendations
 from schooltool.commendation.interfaces import ICommendationContained
@@ -111,7 +112,7 @@
     # Whereever we are, get the SchoolTool application and access its
     # annotations. Then add the commendation to the list of all cached
     # commendations.
-    stapp = app.getSchoolToolApplication()
+    stapp = ISchoolToolApplication(None)
     annotations = IAnnotations(stapp)
     if CommendationsCacheKey not in annotations:
         annotations[CommendationsCacheKey] = persistent.list.PersistentList()

=== modified file 'src/schooltool/contact/configure.zcml'
--- src/schooltool/contact/configure.zcml	2010-01-19 12:09:22 +0000
+++ src/schooltool/contact/configure.zcml	2010-05-28 11:09:37 +0000
@@ -82,10 +82,9 @@
       factory=".basicperson.PersonRemovedSubsciber"
       name="notify_person_contact_removed" />
 
-  <subscriber
-     for="schooltool.app.interfaces.ICatalogSetUpEvent"
-     handler=".contact.catalogSetUpSubscriber"
-     />
+  <adapter
+      factory=".contact.ContactCatalog"
+      name="schooltool.contact.contact.ContactCatalog" />
 
   <adapter
       for=".interfaces.IContactContainer"

=== modified file 'src/schooltool/contact/contact.py'
--- src/schooltool/contact/contact.py	2010-01-19 12:09:22 +0000
+++ src/schooltool/contact/contact.py	2010-05-28 11:09:37 +0000
@@ -25,18 +25,14 @@
 from zope.component import adapter
 from zope.interface import implementer
 from zope.interface import implements
-from zope.catalog.interfaces import ICatalog
 from zope.intid.interfaces import IIntIds
 from zope.container.contained import Contained
 from zope.container.btree import BTreeContainer
 from zope.component import getUtility
 
-from zc.catalog.catalogindex import ValueIndex
-from zc.catalog.extentcatalog import Catalog
-from zc.catalog.extentcatalog import FilterExtent
-
 from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.app import InitBase, StartUpBase
+from schooltool.app.catalog import AttributeCatalog
 from schooltool.utility.utility import UtilitySetUp
 from schooltool.contact.interfaces import IContactPersonInfo
 from schooltool.contact.interfaces import IContactable
@@ -49,7 +45,6 @@
 from schooltool.relationship.relationship import RelationshipSchema
 from schooltool.securitypolicy import crowds
 from schooltool.table.catalog import ConvertingIndex
-from schooltool.table.catalog import FilterImplementing
 from schooltool.table.table import simple_form_key
 from schooltool.person.interfaces import IPerson
 from schooltool.course.section import PersonInstructorsCrowd
@@ -57,8 +52,6 @@
 from schooltool.common import SchoolToolMessage as _
 
 
-CONTACT_CATALOG_KEY = 'schooltool.contact'
-
 URIContactRelationship = URIObject('http://schooltool.org/ns/contact',
                                    'Contact relationship',
                                    'The contact relationship.')
@@ -186,22 +179,17 @@
     return 'contacts.%s%x' % (simple_form_key(contact), doc_id)
 
 
-def catalogFactory():
-    return Catalog(FilterExtent(FilterImplementing(IContact)))
-
-
-def catalogSetUp(catalog):
-    catalog['form_keys'] = ConvertingIndex(converter=IUniqueFormKey)
-    catalog['first_name'] = ValueIndex('first_name')
-    catalog['last_name'] = ValueIndex('last_name')
-
-
-catalogSetUpSubscriber = UtilitySetUp(
-    catalogFactory, ICatalog, CONTACT_CATALOG_KEY, setUp=catalogSetUp)
-
-
-def getContactCatalog(container):
-    return getUtility(ICatalog, CONTACT_CATALOG_KEY)
+class ContactCatalog(AttributeCatalog):
+    version = '1 - replaced catalog utility'
+    interface = IContact
+    attributes = ('first_name', 'last_name')
+
+    def setIndexes(self, catalog):
+        super(ContactCatalog, self).setIndexes(catalog)
+        catalog['form_keys'] = ConvertingIndex(converter=IUniqueFormKey)
+
+
+getContactCatalog = ContactCatalog.get
 
 
 class ContactPersonInstructorsCrowd(PersonInstructorsCrowd):
@@ -218,4 +206,3 @@
                 if user in section.instructors:
                     return True
         return False
-

=== modified file 'src/schooltool/generations/__init__.py'
--- src/schooltool/generations/__init__.py	2010-04-27 13:40:34 +0000
+++ src/schooltool/generations/__init__.py	2010-05-28 11:09:37 +0000
@@ -25,6 +25,6 @@
 from zope.app.generations.generations import SchemaManager
 
 schemaManager = SchemaManager(
-    minimum_generation=34,
-    generation=34,
+    minimum_generation=35,
+    generation=35,
     package_name='schooltool.generations')

=== modified file 'src/schooltool/generations/evolve33.py'
--- src/schooltool/generations/evolve33.py	2010-02-09 16:54:13 +0000
+++ src/schooltool/generations/evolve33.py	2010-05-28 11:09:37 +0000
@@ -25,13 +25,10 @@
 from zope.app.publication.zopepublication import ZopePublication
 from zope.component.hooks import getSite, setSite
 from zope.component import getUtility
-from zope.catalog.interfaces import ICatalog
 
 from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.interfaces import CatalogSetUpEvent
 from schooltool.contact.interfaces import IContact
-from schooltool.contact.contact import catalogSetUpSubscriber
-from schooltool.contact.contact import CONTACT_CATALOG_KEY
 from schooltool.person.interfaces import IPerson
 
 
@@ -46,10 +43,6 @@
         persons = findObjectsProviding(app, IPerson)
         for person in persons:
             contact = IContact(person, None)
-        # regsiter contact catalogs
-        catalogSetUpSubscriber(CatalogSetUpEvent(app))
-        util = getUtility(ICatalog, CONTACT_CATALOG_KEY)
-        util.updateIndexes()
 
     setSite(old_site)
 

=== added file 'src/schooltool/generations/evolve35.py'
--- src/schooltool/generations/evolve35.py	1970-01-01 00:00:00 +0000
+++ src/schooltool/generations/evolve35.py	2010-05-28 11:09:37 +0000
@@ -0,0 +1,59 @@
+#
+# SchoolTool - common information systems platform for school administration
+# Copyright (c) 2010 Shuttleworth Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+"""
+Upgrade SchoolTool to generation 35.
+
+Evolution script to unregister old catalog utilities.
+"""
+from zope.app.generations.utility import findObjectsProviding
+from zope.app.publication.zopepublication import ZopePublication
+from zope.component import queryUtility
+from zope.component.hooks import getSite, setSite
+from zope.traversing.api import traverse
+
+from schooltool.app.interfaces import ISchoolToolApplication
+from zope.catalog.interfaces import ICatalog
+
+
+CATALOG_KEYS = [
+    'schooltool.basicperson',
+    'schooltool.contact',
+    'schooltool.person',
+    ]
+
+
+def evolve(context):
+    root = context.connection.root().get(ZopePublication.root_name, None)
+
+    old_site = getSite()
+    apps = findObjectsProviding(root, ISchoolToolApplication)
+    for app in apps:
+        setSite(app)
+        sm = app.getSiteManager()
+        default = traverse(app, '++etc++site/default')
+
+        for key in CATALOG_KEYS:
+            util = queryUtility(ICatalog, name=key, default=None)
+            if util is None:
+                continue
+            name = util.__name__
+            sm.unregisterUtility(util, ICatalog, key)
+            del default[name]
+
+    setSite(old_site)

=== modified file 'src/schooltool/generations/tests/__init__.py'
--- src/schooltool/generations/tests/__init__.py	2010-01-19 12:09:22 +0000
+++ src/schooltool/generations/tests/__init__.py	2010-05-28 11:09:37 +0000
@@ -48,6 +48,7 @@
 
 
 def catalogSetUp(test):
+    """This code is deprecated, to be used only by old evolution tests."""
     setup.placefulSetUp()
     setup.setUpTraversal()
     setUpAnnotations()
@@ -91,5 +92,6 @@
                    [IIntIdRemovedEvent])
 
 def catalogTearDown(test):
+    """This code is deprecated, to be used only by old evolution tests."""
     setup.placefulTearDown()
     _d.clear()

=== modified file 'src/schooltool/generations/tests/test_evolve33.py'
--- src/schooltool/generations/tests/test_evolve33.py	2010-02-09 19:18:22 +0000
+++ src/schooltool/generations/tests/test_evolve33.py	2010-05-28 11:09:37 +0000
@@ -24,13 +24,12 @@
 
 from zope.app.testing import setup
 
-from zope.component import queryUtility, provideUtility
+from zope.component import provideUtility
 from zope.component import provideAdapter
 from zope.interface import implements
 from zope.intid import IntIds
 from zope.intid.interfaces import IIntIds
 from zope.site.folder import Folder
-from zope.catalog.interfaces import ICatalog
 from zope.container.btree import BTreeContainer
 from zope.component.hooks import getSite, setSite
 
@@ -89,28 +88,6 @@
         >>> print getSite()
         None
 
-    Contact catalog was registered for ISchoolToolApplication sites.
-
-        >>> catalog = queryUtility(ICatalog, 'schooltool.contact')
-        >>> print catalog
-        None
-
-        >>> setSite(app)
-
-        >>> catalog = queryUtility(ICatalog, 'schooltool.contact')
-        >>> catalog
-        <zc.catalog.extentcatalog.Catalog object ...>
-
-    Catalog indexes were set up properly.
-
-        >>> sorted(i.__name__ for i in catalog.values())
-        [u'first_name', u'form_keys', u'last_name']
-
-    And contacts of existing persons got indexed.
-
-        >>> sorted(catalog['first_name'].documents_to_values.values())
-        ['Johny', 'Petey']
-
     """
 
 

=== added file 'src/schooltool/generations/tests/test_evolve35.py'
--- src/schooltool/generations/tests/test_evolve35.py	1970-01-01 00:00:00 +0000
+++ src/schooltool/generations/tests/test_evolve35.py	2010-05-28 11:09:37 +0000
@@ -0,0 +1,123 @@
+#
+# SchoolTool - common information systems platform for school administration
+# Copyright (c) 2010 Shuttleworth Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+"""
+Unit tests for schooltool.generations.evolve35
+"""
+import unittest
+import doctest
+
+from zope.app.testing import setup
+from zope.interface import implements
+from zope.component import queryUtility
+from zope.component.hooks import getSite, setSite
+from zope.traversing.api import traverse
+from zope.site import LocalSiteManager
+from zope.site.folder import Folder
+from zope.location import Location
+from zope.catalog.interfaces import ICatalog
+
+from schooltool.app.interfaces import ISchoolToolApplication
+from schooltool.generations.tests import ContextStub
+from schooltool.generations.evolve35 import CATALOG_KEYS
+
+
+def registerLocalUtility(site, utility, name):
+   manager = site.getSiteManager()
+   default = traverse(site, '++etc++site/default')
+   default['storage.key:'+name] = utility
+   manager.registerUtility(utility, ICatalog, name)
+
+
+class UtilityStub(Folder):
+    def __init__(self, name):
+        super(UtilityStub, self).__init__()
+        self.name = name
+
+    def __repr__(self):
+        return '<%s (%s)>' % (self.__class__.__name__, self.name)
+
+
+class AppStub(Folder):
+    implements(ISchoolToolApplication)
+
+
+def doctest_evolve35():
+    """Test evolution to generation 35.
+
+    First, let's build ST app with local catalog utilities.
+
+        >>> context = ContextStub()
+        >>> context.root_folder['app'] = app = AppStub()
+        >>> app.setSiteManager(LocalSiteManager(app))
+
+        >>> for name in CATALOG_KEYS:
+        ...     registerLocalUtility(app, UtilityStub(name), name)
+
+        >>> setSite(app)
+        >>> for name in CATALOG_KEYS:
+        ...     print queryUtility(ICatalog, name=name, default=None)
+        <UtilityStub (schooltool.basicperson)>
+        <UtilityStub (schooltool.contact)>
+        <UtilityStub (schooltool.person)>
+
+    Set the site to something else and evolve.
+
+        >>> context.root_folder['frob'] = frob = Folder()
+        >>> frob.setSiteManager(LocalSiteManager(frob))
+        >>> setSite(frob)
+
+        >>> from schooltool.generations.evolve35 import evolve
+        >>> evolve(context)
+
+    Active site was kept.
+
+        >>> getSite() is frob
+        True
+
+    And catalogs in our app were unregistered.
+
+        >>> setSite(app)
+        >>> for name in CATALOG_KEYS:
+        ...     print queryUtility(ICatalog, name=name, default=None)
+        None
+        None
+        None
+
+    """
+
+
+def setUp(test):
+    setup.placefulSetUp()
+    setup.setUpTraversal()
+
+
+def tearDown(test):
+    setup.placefulTearDown()
+
+
+def test_suite():
+    optionflags = (doctest.ELLIPSIS |
+                   doctest.NORMALIZE_WHITESPACE |
+                   doctest.REPORT_ONLY_FIRST_FAILURE)
+    return doctest.DocTestSuite(setUp=setUp, tearDown=tearDown,
+                                optionflags=optionflags)
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='test_suite')

=== modified file 'src/schooltool/person/configure.zcml'
--- src/schooltool/person/configure.zcml	2010-01-19 12:09:22 +0000
+++ src/schooltool/person/configure.zcml	2010-05-28 11:09:37 +0000
@@ -91,14 +91,12 @@
       provides=".interfaces.IPerson"
       for="schooltool.person.interfaces.IPersonPreferences" />
 
-  <subscriber
-      for="schooltool.app.interfaces.ICatalogSetUpEvent"
-      handler=".person.catalogSetUpSubscriber"
-      />
+  <adapter factory=".person.PersonCatalog"
+           name="schooltool.person.person.PersonCatalog" />
 
   <adapter
-      for=".interfaces.IPersonContainer"
-      factory=".person.getPersonContainerCatalog"
+      for="schooltool.person.interfaces.IPersonContainer"
+      factory=".person.getPersonCatalog"
       provides="zope.catalog.interfaces.ICatalog" />
 
   <configure

=== modified file 'src/schooltool/person/person.py'
--- src/schooltool/person/person.py	2010-01-27 17:38:36 +0000
+++ src/schooltool/person/person.py	2010-05-28 11:09:37 +0000
@@ -30,16 +30,13 @@
 from zope.container import btree
 from zope.container.contained import Contained
 from zope.component import adapts
-from zope.catalog.interfaces import ICatalog
-from zope.catalog.catalog import Catalog
 from zope.component import getUtility
 
-from zc.catalog.catalogindex import ValueIndex
-
-from schooltool.app.app import getSchoolToolApplication
+from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.interfaces import ISchoolToolCalendar
 from schooltool.app.membership import URIMembership, URIMember, URIGroup
 from schooltool.app.overlay import OverlaidCalendarsProperty
+from schooltool.app.catalog import AttributeCatalog
 from schooltool.person import interfaces
 from schooltool.relationship import RelationshipProperty
 from schooltool.securitypolicy.crowds import Crowd
@@ -51,8 +48,6 @@
 from schooltool.securitypolicy.crowds import OwnerCrowd, AggregateCrowd
 from schooltool.utility.utility import UtilitySetUp
 
-PERSON_CATALOG_KEY = 'schooltool.person'
-
 
 class PersonContainer(btree.BTreeContainer):
     """Container of persons."""
@@ -136,16 +131,15 @@
 def personAppCalendarOverlaySubscriber(person, event):
     """Add application calendar to overlays of all new persons.
     """
-    try:
-        app = getSchoolToolApplication()
-        person.overlaid_calendars.add(ISchoolToolCalendar(app))
-    except ValueError:
+    app = ISchoolToolApplication(None, None)
+    if app is None:
         # If we get this we are probably in the initial new-site setup
         # or creating a new manager during startup.  This should be
         # safe to ignore since it will happen very infrequently
         # (perhaps only once) and the manager can easily add the site
         # calendar to his/her overlay in the overlay selection view.
-        pass
+        return
+    person.overlaid_calendars.add(ISchoolToolCalendar(app))
 
 
 from schooltool.app.app import InitBase
@@ -208,14 +202,10 @@
                 OwnerCrowd(self.context.person).contains(principal))
 
 
-def catalogSetUp(catalog):
-    catalog['__name__'] = ValueIndex('__name__', IPerson)
-    catalog['title'] = ValueIndex('title', IPerson)
-
-
-catalogSetUpSubscriber = UtilitySetUp(
-    Catalog, ICatalog, PERSON_CATALOG_KEY, setUp=catalogSetUp)
-
-
-def getPersonContainerCatalog(container):
-    return getUtility(ICatalog, PERSON_CATALOG_KEY)
+class PersonCatalog(AttributeCatalog):
+
+    version = '1 - replaced catalog utility'
+    interface = IPerson
+    attributes = ('__name__', 'title')
+
+getPersonCatalog = PersonCatalog.get

=== modified file 'src/schooltool/resource/types.py'
--- src/schooltool/resource/types.py	2007-10-15 16:20:41 +0000
+++ src/schooltool/resource/types.py	2010-05-28 11:09:37 +0000
@@ -29,8 +29,8 @@
 from zc.table.column import GetterColumn
 from zc.table.interfaces import ISortableColumn
 
+from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.common import SchoolToolMessage as _
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.resource.interfaces import (IResource, IResourceFactoryUtility,
                                             ILocation, IEquipment,
                                             IResourceTypeInformation,
@@ -45,7 +45,7 @@
         self.interface = IResource
 
     def types(self):
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         types = set()
         for resource in app['resources'].values():
             if self.interface.providedBy(resource):

=== modified file 'src/schooltool/skin/skin.py'
--- src/schooltool/skin/skin.py	2010-01-08 14:03:27 +0000
+++ src/schooltool/skin/skin.py	2010-05-28 11:09:37 +0000
@@ -43,8 +43,6 @@
 from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.skin.interfaces import IBreadcrumbInfo
 
-from schooltool.app.app import getSchoolToolApplication
-
 
 class IJavaScriptManager(IViewletManager):
     """Provides a viewlet hook for the javascript link entries."""
@@ -141,7 +139,7 @@
         return ISchoolToolApplication(None)
 
     def appURL(self):
-        return absoluteURL(getSchoolToolApplication(), self.request)
+        return absoluteURL(ISchoolToolApplication(None), self.request)
 
 
 class TopLevelContainerNavigationViewlet(NavigationViewlet):

=== modified file 'src/schooltool/term/browser/emergency.py'
--- src/schooltool/term/browser/emergency.py	2008-09-26 17:35:45 +0000
+++ src/schooltool/term/browser/emergency.py	2010-05-28 11:09:37 +0000
@@ -32,8 +32,8 @@
 
 from schooltool.schoolyear.interfaces import ISchoolYear
 from schooltool.common import SchoolToolMessage as _
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.app.cal import CalendarEvent
+from schooltool.app.interfaces import ISchoolToolApplication
 from schooltool.app.interfaces import ISchoolToolCalendar
 from schooltool.calendar.utils import parse_date
 from schooltool.term.interfaces import ITerm
@@ -122,7 +122,7 @@
                 exceptionDayIds[self.replacement] = removeSecurityProxy(day_id)
 
             # Post calendar events to schoolwide calendar
-            calendar = ISchoolToolCalendar(getSchoolToolApplication())
+            calendar = ISchoolToolCalendar(ISchoolToolApplication(None))
             dtstart = datetime.datetime.combine(self.date, datetime.time())
             msg = _('School cancelled due to emergency.'
                     ' Replacement day $replacement.',

=== modified file 'src/schooltool/timetable/__init__.py'
--- src/schooltool/timetable/__init__.py	2010-01-19 12:09:22 +0000
+++ src/schooltool/timetable/__init__.py	2010-05-28 11:09:37 +0000
@@ -135,7 +135,6 @@
 from zope.interface import implementer
 from zope.interface import implements
 from zope.interface import directlyProvides
-
 from zope.annotation.interfaces import IAnnotations
 from zope.location.interfaces import ILocation
 from zope.traversing.api import getPath
@@ -143,10 +142,9 @@
 from zope.container.contained import NameChooser
 from zope.app.generations.utility import findObjectsProviding
 
+from schooltool.app.interfaces import ISchoolToolApplication
+from schooltool.app.interfaces import ISchoolToolCalendar
 from schooltool.calendar.simple import ImmutableCalendar
-
-from schooltool.app.interfaces import ISchoolToolCalendar
-
 from schooltool.timetable.interfaces import ITimetableCalendarEvent
 from schooltool.timetable.interfaces import ITimetable, ITimetableWrite
 from schooltool.timetable.interfaces import ITimetableDay, ITimetableDayWrite
@@ -164,7 +162,6 @@
 from schooltool.timetable.interfaces import ITimetableSchema
 from schooltool.timetable.interfaces import Unchanged
 from schooltool.term.interfaces import ITerm
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.app.app import InitBase
 
 from schooltool.common import SchoolToolMessage as _
@@ -673,7 +670,7 @@
 
 
 def getAllTimetables():
-    app = getSchoolToolApplication(None)
+    app = ISchoolToolApplication(None)
     all_timetables = []
     for ttowner in findObjectsProviding(app, IOwnTimetables):
         timetables = queryAdapter(ttowner, ITimetables, default=None)

=== modified file 'src/schooltool/timetable/browser/__init__.py'
--- src/schooltool/timetable/browser/__init__.py	2010-05-03 11:24:06 +0000
+++ src/schooltool/timetable/browser/__init__.py	2010-05-28 11:09:37 +0000
@@ -32,7 +32,6 @@
 from zope.traversing.browser.absoluteurl import absoluteURL
 
 from schooltool.app.interfaces import ISchoolToolApplication
-from schooltool.app.app import getSchoolToolApplication
 from schooltool.calendar.utils import parse_date, parse_time
 from schooltool.course.interfaces import ISection
 from schooltool.term.interfaces import ITerm
@@ -369,7 +368,7 @@
 
         If there are no timetable schemas, None is returned.
         """
-        app = getSchoolToolApplication()
+        app = ISchoolToolApplication(None)
         ttschemas = ITimetableSchemaContainer(app, None)
         if ttschemas is None:
             return None

=== modified file 'src/schooltool/utility/utility.py'
--- src/schooltool/utility/utility.py	2009-11-19 02:00:46 +0000
+++ src/schooltool/utility/utility.py	2010-05-28 11:09:37 +0000
@@ -61,7 +61,8 @@
            if spec.override:
                # override existing utility
                name = local_utility.__name__
-               manager.unregisterUtility(local_utility, spec.iface, name)
+               manager.unregisterUtility(
+                   local_utility, spec.iface, spec.utility_name)
                del default[name]
            else:
                # do not register this utility; we already got it