Commit abbd78bf authored by 's avatar

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)
parent adbd86c9
......@@ -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
......
......@@ -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 ):
......
......@@ -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."
......
......@@ -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):
......
......@@ -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"
......
......@@ -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)
......
......@@ -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'
......
......@@ -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):
......
......@@ -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')
......
......@@ -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])
......
......@@ -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):
......
......@@ -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):
......
......@@ -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 ##
......
......@@ -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):
......
......@@ -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'
......
......@@ -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)
"""
......@@ -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..
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment