[Checkins] SVN: zope.index/trunk/ TextIndex: reuse lexicon from the underlying Okapi / Cosine index, if passed.

[Tres Seaver]

Log message for revision 114347:
  TextIndex:  reuse lexicon from the underlying Okapi / Cosine  index, if passed.
  
  Fixes LP #232516.
  

Changed:
  U   zope.index/trunk/CHANGES.txt
  U   zope.index/trunk/src/zope/index/text/tests/test_textindex.py
  U   zope.index/trunk/src/zope/index/text/textindex.py

-=-
Modified: zope.index/trunk/CHANGES.txt
===================================================================
--- zope.index/trunk/CHANGES.txt	2010-07-08 17:52:16 UTC (rev 114346)
+++ zope.index/trunk/CHANGES.txt	2010-07-08 17:52:17 UTC (rev 114347)
@@ -4,8 +4,11 @@
 Unreleased
 ----------
 
-- Avoid raising an exception when indexing None. (LP #598776)
+- TextIndex:  reuse the lexicon from the underlying Okapi / Cosine
+  index, if passed.  (LP #232516)
 
+- Lexicon:  avoid raising an exception when indexing None. (LP #598776)
+
 3.6.0 (2009-08-03)
 ------------------
 

Modified: zope.index/trunk/src/zope/index/text/tests/test_textindex.py
===================================================================
--- zope.index/trunk/src/zope/index/text/tests/test_textindex.py	2010-07-08 17:52:16 UTC (rev 114346)
+++ zope.index/trunk/src/zope/index/text/tests/test_textindex.py	2010-07-08 17:52:17 UTC (rev 114347)
@@ -106,19 +106,12 @@
         self.failUnless(index.index._lexicon is lexicon)
 
     def test_ctor_explicit_index(self):
-        from zope.index.text.lexicon import CaseNormalizer
-        from zope.index.text.lexicon import Lexicon
-        from zope.index.text.lexicon import Splitter
-        from zope.index.text.lexicon import StopWordRemover
-        okapi = object()
+        lexicon = object()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(index=okapi)
         self.failUnless(index.index is okapi)
-        self.failUnless(isinstance(index.lexicon, Lexicon))
-        pipeline = index.lexicon._pipeline
-        self.assertEqual(len(pipeline), 3)
-        self.failUnless(isinstance(pipeline[0], Splitter))
-        self.failUnless(isinstance(pipeline[1], CaseNormalizer))
-        self.failUnless(isinstance(pipeline[2], StopWordRemover))
+        # See LP #232516
+        self.failUnless(index.lexicon is lexicon)
 
     def test_ctor_explicit_lexicon_and_index(self):
         lexicon = object()
@@ -129,40 +122,40 @@
 
     def test_index_doc(self):
         lexicon = object()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(lexicon, okapi)
         index.index_doc(1, 'cats and dogs')
         self.assertEqual(okapi._indexed[0], (1, 'cats and dogs'))
 
     def test_unindex_doc(self):
         lexicon = object()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(lexicon, okapi)
         index.unindex_doc(1)
         self.assertEqual(okapi._unindexed[0], 1)
 
     def test_clear(self):
         lexicon = object()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(lexicon, okapi)
         index.clear()
         self.failUnless(okapi._cleared)
 
     def test_documentCount(self):
         lexicon = object()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(lexicon, okapi)
         self.assertEqual(index.documentCount(), 4)
 
     def test_wordCount(self):
         lexicon = object()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(lexicon, okapi)
         self.assertEqual(index.wordCount(), 45)
 
     def test_apply_no_results(self):
         lexicon = DummyLexicon()
-        okapi = DummyOkapi({})
+        okapi = DummyOkapi(lexicon, {})
         index = self._makeOne(lexicon, okapi)
         self.assertEqual(index.apply('anything'), {})
         self.assertEqual(okapi._query_weighted, [])
@@ -170,7 +163,7 @@
 
     def test_apply_w_results(self):
         lexicon = DummyLexicon()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         index = self._makeOne(lexicon, okapi)
         results = index.apply('anything')
         self.assertEqual(results[1], 14.0 / 42.0)
@@ -181,7 +174,7 @@
 
     def test_apply_w_results_zero_query_weight(self):
         lexicon = DummyLexicon()
-        okapi = DummyOkapi()
+        okapi = DummyOkapi(lexicon)
         okapi._query_weight = 0
         index = self._makeOne(lexicon, okapi)
         results = index.apply('anything')
@@ -196,7 +189,7 @@
         DIVISOR = sys.maxint / 10
         lexicon = DummyLexicon()
         # cause TypeError in division
-        okapi = DummyOkapi({1: '14.0', 2: '7.4', 3: '3.2'})
+        okapi = DummyOkapi(lexicon, {1: '14.0', 2: '7.4', 3: '3.2'})
         index = self._makeOne(lexicon, okapi)
         results = index.apply('anything')
         self.assertEqual(results[1], DIVISOR)
@@ -212,7 +205,8 @@
     _word_count = 45
     _query_weight = 42.0
 
-    def __init__(self, search_results=None):
+    def __init__(self, lexicon, search_results=None):
+        self.lexicon = lexicon
         self._indexed = []
         self._unindexed = []
         self._searched = []

Modified: zope.index/trunk/src/zope/index/text/textindex.py
===================================================================
--- zope.index/trunk/src/zope/index/text/textindex.py	2010-07-08 17:52:16 UTC (rev 114346)
+++ zope.index/trunk/src/zope/index/text/textindex.py	2010-07-08 17:52:17 UTC (rev 114347)
@@ -37,11 +37,13 @@
 
         This creates the lexicon and index if not passed in.
         """
+        _explicit_lexicon = True
         if lexicon is None:
+            _explicit_lexicon = False
             lexicon = Lexicon(Splitter(), CaseNormalizer(), StopWordRemover())
         if index is None:
             index = OkapiIndex(lexicon)
-        self.lexicon = lexicon
+        self.lexicon = _explicit_lexicon and lexicon or index.lexicon
         self.index = index
 
     def index_doc(self, docid, text):