reverted r30999, removed all Five dependencies introduced in r30994

(this fixes the infinite loop issue, but adds redundant interface definitions because we can't use Five's bridging code)

lib/python/Products/PluginIndexes/DateIndex/tests/test_DateIndex.py

@@ -172,9 +172,9 @@ class DI_Tests(unittest.TestCase):
         from zope.interface.verify import verifyClass
 
         verifyClass(IDateIndex, DateIndex)
-        verifyClass(IPluggableIndex, DateIndex, 1)
-        verifyClass(ISortIndex, DateIndex, 1)
-        verifyClass(IUniqueValueIndex, DateIndex, 1)
+        verifyClass(IPluggableIndex, DateIndex)
+        verifyClass(ISortIndex, DateIndex)
+        verifyClass(IUniqueValueIndex, DateIndex)
 
     def test_empty(self):
         empty = self._index

lib/python/Products/PluginIndexes/DateRangeIndex/tests/test_DateRangeIndex.py

@@ -88,9 +88,9 @@ class DRI_Tests( unittest.TestCase ):
         from zope.interface.verify import verifyClass
 
         verifyClass(IDateRangeIndex, DateRangeIndex)
-        verifyClass(IPluggableIndex, DateRangeIndex, 1)
-        verifyClass(ISortIndex, DateRangeIndex, 1)
-        verifyClass(IUniqueValueIndex, DateRangeIndex, 1)
+        verifyClass(IPluggableIndex, DateRangeIndex)
+        verifyClass(ISortIndex, DateRangeIndex)
+        verifyClass(IUniqueValueIndex, DateRangeIndex)
 
     def test_empty( self ):
 

lib/python/Products/PluginIndexes/FieldIndex/tests/testFieldIndex.py

@@ -100,9 +100,9 @@ class FieldIndexTests(unittest.TestCase):
         from Products.PluginIndexes.interfaces import IUniqueValueIndex
         from zope.interface.verify import verifyClass
 
-        verifyClass(IPluggableIndex, FieldIndex, 1)
-        verifyClass(ISortIndex, FieldIndex, 1)
-        verifyClass(IUniqueValueIndex, FieldIndex, 1)
+        verifyClass(IPluggableIndex, FieldIndex)
+        verifyClass(ISortIndex, FieldIndex)
+        verifyClass(IUniqueValueIndex, FieldIndex)
 
     def testEmpty( self ):
         "Test an empty FieldIndex."

lib/python/Products/PluginIndexes/KeywordIndex/tests/testKeywordIndex.py

@@ -120,9 +120,9 @@ class TestKeywordIndex( unittest.TestCase ):
         from Products.PluginIndexes.interfaces import IUniqueValueIndex
         from zope.interface.verify import verifyClass
 
-        verifyClass(IPluggableIndex, KeywordIndex, 1)
-        verifyClass(ISortIndex, KeywordIndex, 1)
-        verifyClass(IUniqueValueIndex, KeywordIndex, 1)
+        verifyClass(IPluggableIndex, KeywordIndex)
+        verifyClass(ISortIndex, KeywordIndex)
+        verifyClass(IUniqueValueIndex, KeywordIndex)
 
     def testAddObjectWOKeywords(self):
 

lib/python/Products/PluginIndexes/PathIndex/PathIndex.py

@@ -30,6 +30,7 @@ from Products.PluginIndexes import PluggableIndex
 from Products.PluginIndexes.common import safe_callable
 from Products.PluginIndexes.common.util import parseIndexRequest
 from Products.PluginIndexes.interfaces import IPathIndex
+from Products.PluginIndexes.interfaces import IUniqueValueIndex
 
 _marker = []
 LOG = getLogger('Zope.PathIndex')
@@ -52,7 +53,7 @@ class PathIndex(Persistent, SimpleItem):
     """
 
     __implements__ = (PluggableIndex.UniqueValueIndex,)
-    implements(IPathIndex)
+    implements(IPathIndex, IUniqueValueIndex)
 
     meta_type="PathIndex"
 

lib/python/Products/PluginIndexes/PathIndex/tests/testPathIndex.py

@@ -75,7 +75,7 @@ class PathIndexTests(unittest.TestCase):
         from zope.interface.verify import verifyClass
 
         verifyClass(IPathIndex, PathIndex)
-        verifyClass(IUniqueValueIndex, PathIndex, 1)
+        verifyClass(IUniqueValueIndex, PathIndex)
 
     def testEmpty(self):
         self.assertEqual(self._index.numObjects() ,0)

lib/python/Products/PluginIndexes/TextIndex/TextIndex.py

@@ -34,6 +34,7 @@ from Products.PluginIndexes import PluggableIndex
 from Products.PluginIndexes.common import safe_callable
 from Products.PluginIndexes.common.ResultList import ResultList
 from Products.PluginIndexes.common.util import parseIndexRequest
+from Products.PluginIndexes.interfaces import IPluggableIndex
 from Products.PluginIndexes.interfaces import ITextIndex
 
 from Lexicon import Lexicon
@@ -77,7 +78,7 @@ class TextIndex(Persistent, Implicit, SimpleItem):
     """
 
     __implements__ = (PluggableIndex.PluggableIndexInterface,)
-    implements(ITextIndex)
+    implements(ITextIndex, IPluggableIndex)
 
     meta_type='TextIndex'
 

lib/python/Products/PluginIndexes/TextIndex/tests/testTextIndex.py

@@ -92,7 +92,7 @@ class Tests(unittest.TestCase):
         from Products.PluginIndexes.TextIndex.TextIndex import TextIndex
         from zope.interface.verify import verifyClass
 
-        verifyClass(IPluggableIndex, TextIndex, 1)
+        verifyClass(IPluggableIndex, TextIndex)
         verifyClass(ITextIndex, TextIndex)
 
     def test_SimpleAddDelete(self):

lib/python/Products/PluginIndexes/TopicIndex/TopicIndex.py

@@ -25,6 +25,7 @@ from zope.interface import implements
 
 from Products.PluginIndexes import PluggableIndex
 from Products.PluginIndexes.common.util import parseIndexRequest
+from Products.PluginIndexes.interfaces import IPluggableIndex
 from Products.PluginIndexes.interfaces import ITopicIndex
 
 import FilteredSet
@@ -42,7 +43,7 @@ class TopicIndex(Persistent, SimpleItem):
     """
 
     __implements__ = (PluggableIndex.PluggableIndexInterface,)
-    implements(ITopicIndex)
+    implements(ITopicIndex, IPluggableIndex)
 
     meta_type="TopicIndex"
     query_options = ('query','operator')

lib/python/Products/PluginIndexes/TopicIndex/tests/testTopicIndex.py

@@ -71,7 +71,7 @@ class TestTopicIndex(TestBase):
         from zope.interface.verify import verifyClass
 
         verifyClass(ITopicIndex, TopicIndex)
-        verifyClass(IPluggableIndex, TopicIndex, 1)
+        verifyClass(IPluggableIndex, TopicIndex)
 
     def testOr(self):
         self._searchOr('doc1',[1,2])

lib/python/Products/PluginIndexes/common/UnIndex.py

@@ -24,10 +24,14 @@ from BTrees.IOBTree import IOBTree
 import BTrees.Length
 from BTrees.OOBTree import OOBTree
 from OFS.SimpleItem import SimpleItem
+from zope.interface import implements
 
 from Products.PluginIndexes import PluggableIndex
 from Products.PluginIndexes.common import safe_callable
 from Products.PluginIndexes.common.util import parseIndexRequest
+from Products.PluginIndexes.interfaces import IPluggableIndex
+from Products.PluginIndexes.interfaces import ISortIndex
+from Products.PluginIndexes.interfaces import IUniqueValueIndex
 
 _marker = []
 LOG = getLogger('Zope.UnIndex')
@@ -40,6 +44,7 @@ class UnIndex(SimpleItem):
 
     __implements__ = (PluggableIndex.UniqueValueIndex,
                       PluggableIndex.SortIndex)
+    implements(IPluggableIndex, IUniqueValueIndex, ISortIndex)
 
     def __init__(
         self, id, ignore_ex=None, call_methods=None, extra=None, caller=None):

lib/python/Products/PluginIndexes/interfaces.py

@@ -19,22 +19,97 @@ from zope.interface import Interface
 from zope.schema import Bool
 
 
-# create IPluggableIndex, IUniqueValueIndex, ISortIndex
-from Products.Five.fiveconfigure import createZope2Bridge
-from common.PluggableIndex import PluggableIndexInterface
-from common.PluggableIndex import SortIndex
-from common.PluggableIndex import UniqueValueIndex
-import interfaces
-
-createZope2Bridge(PluggableIndexInterface, interfaces, 'IPluggableIndex')
-createZope2Bridge(SortIndex, interfaces, 'ISortIndex')
-createZope2Bridge(UniqueValueIndex, interfaces, 'IUniqueValueIndex')
-
-del createZope2Bridge
-del PluggableIndexInterface
-del SortIndex
-del UniqueValueIndex
-del interfaces
+# XXX: copied from common.PluggableIndex.PluggableIndexInterface;
+#      should be bridged
+class IPluggableIndex(Interface):
+
+    def getId():
+        """Return Id of index."""
+
+    def getEntryForObject(documentId, default=None):
+        """Get all information contained for 'documentId'."""
+
+    def getIndexSourceNames():
+        """ return a sequence of attribute names that are indexed 
+            by the index. 
+        """
+
+    def index_object(documentId, obj, threshold=None):
+        """Index an object.
+
+        'documentId' is the integer ID of the document.
+        'obj' is the object to be indexed.
+        'threshold' is the number of words to process between committing
+        subtransactions.  If None, subtransactions are disabled.
+        """
+
+    def unindex_object(documentId):
+        """Remove the documentId from the index."""
+
+    def _apply_index(request, cid=''):
+        """Apply the index to query parameters given in 'request'.
+
+        The argument should be a mapping object.
+
+        If the request does not contain the needed parametrs, then
+        None is returned.
+
+        If the request contains a parameter with the name of the column
+        + "_usage", it is sniffed for information on how to handle applying
+        the index. (Note: this style or parameters is deprecated)
+
+        If the request contains a parameter with the name of the
+        column and this parameter is either a Record or a class
+        instance then it is assumed that the parameters of this index
+        are passed as attribute (Note: this is the recommended way to
+        pass parameters since Zope 2.4)
+
+        Otherwise two objects are returned.  The first object is a
+        ResultSet containing the record numbers of the matching
+        records.  The second object is a tuple containing the names of
+        all data fields used.
+        """
+    
+    def numObjects():
+        """Return the number of indexed objects"""
+
+# XXX: this is currently broken
+#    def indexSize():
+#        """Return the size of the index in terms of distinct values"""
+    
+    def clear():
+        """Empty the index"""
+
+
+# XXX: copied from from common.PluggableIndex.UniqueValueIndex;
+#      should be bridged
+class IUniqueValueIndex(IPluggableIndex):
+    """An index which can return lists of unique values contained in it"""
+    
+    def hasUniqueValuesFor(name):
+        """Return true if the index can return the unique values for name"""
+        
+    def uniqueValues(name=None, withLengths=0):
+        """Return the unique values for name.
+
+        If 'withLengths' is true, returns a sequence of tuples of
+        (value, length)."""
+
+
+# XXX: copied from from common.PluggableIndex.SortIndex;
+#      should be bridged
+class ISortIndex(IPluggableIndex):
+    """An index which may be used to sort a set of document ids"""
+    
+    def keyForDocument(documentId):
+        """Return the sort key that cooresponds to the specified document id
+        
+        This method is no longer used by ZCatalog, but is left for backwards 
+        compatibility."""
+        
+    def documentToKeyMap():
+        """Return an object that supports __getitem__ and may be used to quickly
+        lookup the sort key given a document id"""
 
 
 class IDateIndex(Interface):

lib/python/Products/ZCTextIndex/ZCTextIndex.py

@@ -31,6 +31,7 @@ from Products.PluginIndexes.common.PluggableIndex import \
      PluggableIndexInterface
 from Products.PluginIndexes.common.util import parseIndexRequest
 from Products.PluginIndexes.common import safe_callable
+from Products.PluginIndexes.interfaces import IPluggableIndex
 
 from Products.ZCTextIndex.ILexicon import ILexicon
 from Products.ZCTextIndex.Lexicon import \
@@ -54,7 +55,7 @@ class ZCTextIndex(Persistent, Acquisition.Implicit, SimpleItem):
     """
 
     __implements__ = PluggableIndexInterface
-    implements(IZCTextIndex)
+    implements(IZCTextIndex, IPluggableIndex)
 
     ## Magic class attributes ##
 

lib/python/Products/ZCTextIndex/tests/testZCTextIndex.py

@@ -267,7 +267,7 @@ class CosineIndexTests(ZCIndexTestsBase, testIndex.CosineIndexTest):
         from Products.ZCTextIndex.interfaces import IZCTextIndex
         from zope.interface.verify import verifyClass
 
-        verifyClass(IPluggableIndex, ZCTextIndex, 1)
+        verifyClass(IPluggableIndex, ZCTextIndex)
         verifyClass(IZCTextIndex, ZCTextIndex)
 
     def testRanking(self):

lib/python/Products/ZCatalog/ZCatalog.py

@@ -37,8 +37,10 @@ from Products.PluginIndexes.common.PluggableIndex \
      import PluggableIndexInterface
 from Products.PluginIndexes.TextIndex import Splitter
 from zLOG import LOG
+from zope.interface import implements
 
 from Catalog import Catalog, CatalogError
+from interfaces import IZCatalog as z3IZCatalog
 from IZCatalog import IZCatalog as z2IZCatalog
 from ProgressHandler import ZLogHandler
 from ZCatalogIndexes import ZCatalogIndexes
@@ -81,6 +83,7 @@ class ZCatalog(Folder, Persistent, Implicit):
     """
 
     __implements__ = z2IZCatalog
+    implements(z3IZCatalog)
 
     meta_type = "ZCatalog"
     icon='misc_/ZCatalog/ZCatalog.gif'

lib/python/Products/ZCatalog/interfaces.py

@@ -15,13 +15,239 @@
 $Id$
 """
 
-# create IZCatalog
-from Products.Five.fiveconfigure import createZope2Bridge
-from IZCatalog import IZCatalog as z2IZCatalog
-import interfaces
+from zope.interface import Interface
 
-createZope2Bridge(z2IZCatalog, interfaces, 'IZCatalog')
 
-del createZope2Bridge
-del z2IZCatalog
-del interfaces
+# XXX: copied from IZCatalog.IZCatalog;
+#      should be bridged
+class IZCatalog(Interface):
+    """ZCatalog object
+
+    A ZCatalog contains arbitrary index like references to Zope
+    objects.  ZCatalog's can index object attribute using a variety
+    of "plug-in" index types.
+
+    Several index types are included, and others may be added.
+
+      Text -- Text indexes index textual content.  The index can be
+      used to search for objects containing certain words.
+
+      Field -- Field indexes index atomic values.  The index can be
+      used to search for objects that have certain properties.
+
+      Keyword -- Keyword indexes index sequences of values.  The index
+      can be used to search for objects that match one or more of the
+      search terms.
+
+      Path -- Path indexes index URI paths. They allow you to find objects
+      based on their placement in a hierarchy.
+
+      Date -- Date indexes index date and type data. They are a type of field
+      index specifically optimized for indexing dates.
+
+      Date Range -- Date range indexes index time intervals. They are designed
+      for efficient searching of dates falling between two boundaries
+      (such as effective / expiration dates).
+
+      Topic -- Topic indexes store prefiltered sets of documents. They are used
+      to optimize complex queries into a single fast query by prefiltering
+      documents by an expression
+
+    The ZCatalog can maintain a table of extra data about cataloged
+    objects.  This information can be used on search result pages to
+    show information about a search result.
+
+    The meta-data table schema is used to build the schema for
+    ZCatalog Result objects.  The objects have the same attributes
+    as the column of the meta-data table.
+
+    ZCatalog does not store references to the objects themselves, but
+    rather to a unique identifier that defines how to get to the
+    object.  In Zope, this unique identifier is the object's relative
+    path to the ZCatalog (since two Zope objects cannot have the same
+    URL, this is an excellent unique qualifier in Zope).
+
+    """
+
+    def catalog_object(obj, uid, idxs=None, update_metadata=1):
+        """Catalogs the object 'obj' with the unique identifier 'uid'.
+
+        The uid must be a physical path, either absolute or relative to
+        the catalog.
+
+        If provided, idxs specifies the names of indexes to update.
+
+        If update_metadata is specified (the default), the object's metadata
+        is updated.  If it is not, the metadata is left untouched.  This
+        flag has no effect if the object is not yet cataloged (metadata
+        is always added for new objects).
+        """
+
+    def uncatalog_object(uid):
+        """Uncatalogs the object with the unique identifier 'uid'.
+
+        The uid must be a physical path, either absolute or relative to
+        the catalog.
+        """
+
+    def uniqueValuesFor(name):
+        """returns the unique values for a given FieldIndex named 'name'.
+        """
+
+    def getpath(rid):
+        """Return the path to a cataloged object given a 'data_record_id_'
+        """
+
+    def getrid(rid):
+        """Return the 'data_record_id_' to a cataloged object given a path
+        """
+
+    def getobject(rid, REQUEST=None):
+        """Return a cataloged object given a 'data_record_id_'
+        """
+
+    def schema():
+        """Get the meta-data schema
+
+        Returns a sequence of names that correspond to columns in the
+        meta-data table.
+
+        """
+
+    def indexes():
+        """Returns a sequence of names that correspond to indexes.
+        """
+
+    def index_objects():
+        """Returns a sequence of actual index objects.
+
+        NOTE: This returns unwrapped indexes! You should probably use
+        getIndexObjects instead. Some indexes expect to be wrapped.
+        """
+
+    def getIndexObjects():
+        """Returns a list of acquisition wrapped index objects
+        """
+
+    def searchResults(REQUEST=None, **kw):
+        """Search the catalog.
+
+        Search terms can be passed in the REQUEST or as keyword
+        arguments.
+
+        Search queries consist of a mapping of index names to search
+        parameters.  You can either pass a mapping to searchResults as
+        the variable 'REQUEST' or you can use index names and search
+        parameters as keyword arguments to the method, in other words::
+
+          searchResults(title='Elvis Exposed',
+                        author='The Great Elvonso')
+
+        is the same as::
+
+          searchResults({'title' : 'Elvis Exposed',
+                         'author : 'The Great Elvonso'})
+
+        In these examples, 'title' and 'author' are indexes.  This
+        query will return any objects that have the title *Elvis
+        Exposed* AND also are authored by *The Great Elvonso*.  Terms
+        that are passed as keys and values in a searchResults() call
+        are implicitly ANDed together. To OR two search results, call
+        searchResults() twice and add concatenate the results like this::
+
+          results = ( searchResults(title='Elvis Exposed') +
+                      searchResults(author='The Great Elvonso') )
+
+        This will return all objects that have the specified title OR
+        the specified author.
+
+        There are some special index names you can pass to change the
+        behavior of the search query:
+
+          sort_on -- This parameters specifies which index to sort the
+          results on.
+
+          sort_order -- You can specify 'reverse' or 'descending'.
+          Default behavior is to sort ascending.
+
+          sort_limit -- An optimization hint to tell the catalog how many
+          results you are really interested in. See the limit argument
+          to the search method for more details.
+
+        There are some rules to consider when querying this method:
+
+            - an empty query mapping (or a bogus REQUEST) returns all
+              items in the catalog.
+
+            - results from a query involving only field/keyword
+              indexes, e.g.  {'id':'foo'} and no 'sort_on' will be
+              returned unsorted.
+
+            - results from a complex query involving a field/keyword
+              index *and* a text index,
+              e.g. {'id':'foo','PrincipiaSearchSource':'bar'} and no
+              'sort_on' will be returned unsorted.
+
+            - results from a simple text index query
+              e.g.{'PrincipiaSearchSource':'foo'} will be returned
+              sorted in descending order by 'score'.  A text index
+              cannot beused as a 'sort_on' parameter, and attempting
+              to do so will raise an error.
+
+        Depending on the type of index you are querying, you may be
+        able to provide more advanced search parameters that can
+        specify range searches or wildcards.  These features are
+        documented in The Zope Book.
+
+        """
+
+    def __call__(REQUEST=None, **kw):
+        """Search the catalog, the same way as 'searchResults'.
+        """
+
+    def search(query_request, sort_index=None, reverse=0, limit=None, merge=1):
+        """Programmatic search interface, use for searching the catalog from
+        scripts.
+
+        query_request -- Dictionary containing catalog query. This uses the
+        same format as searchResults.
+
+        sort_index -- Name of sort index
+
+        reverse -- Boolean, reverse sort order (defaults to false)
+
+        limit -- Limit sorted result count to the n best records. This is an
+        optimization hint used in conjunction with a sort_index. If possible
+        ZCatalog will use a different sort algorithm that uses much less memory
+        and scales better then a full sort. The actual number of records
+        returned is not guaranteed to be <= limit. You still need to apply the
+        same batching to the results. Since the len() of the results will no
+        longer be the actual result count, you can use the
+        "actual_result_count" attribute of the lazy result object instead to
+        determine the size of the full result set.
+
+        merge -- Return merged, lazy results (like searchResults) or raw
+        results for later merging. This can be used to perform multiple
+        queries (even across catalogs) and merge and sort the combined results.
+        """
+
+    def refreshCatalog(clear=0, pghandler=None):
+        """Reindex every object we can find, removing the unreachable
+        ones from the index.
+
+        clear -- values: 1|0  clear the catalog before reindexing
+
+        pghandler -- optional Progresshandler as defined in ProgressHandler.py
+        (see also README.txt)
+        """
+
+    def reindexIndex(name, REQUEST, pghandler=None):
+        """Reindex a single index.
+
+        name -- id of index
+
+        REQUEST -- REQUEST object
+
+        pghandler -- optional Progresshandler as defined in ProgressHandler.py
+        (see also README.txt)
+        """

lib/python/Products/ZCatalog/tests/testCatalog.py

@@ -193,7 +193,7 @@ class TestZCatalog(unittest.TestCase):
         from Products.ZCatalog.ZCatalog import ZCatalog
         from zope.interface.verify import verifyClass
 
-        verifyClass(IZCatalog, ZCatalog, 1)
+        verifyClass(IZCatalog, ZCatalog)
 
     def testGetMetadataForUID(self):
         testNum = str(self.upper - 3) # as good as any..