Ticket #2138: wiki_engine_state_in_WikiSystem.patch

trac/wiki/api.py

@@ -23 +23 @@
     import dummy_threading as threading
 import time
 import urllib
+import re
 
 from trac.core import *
 from trac.util import to_utf8, TRUE
@@ -81 +82 @@
         self._index = None
         self._last_index_update = 0
         self._index_lock = threading.RLock()
+        self._compiled_rules = None
+        self._link_resolvers = None
+        self._helper_patterns = None
+        self._external_handlers = None
 
     def _update_index(self):
         self._index_lock.acquire()
@@ -116 +121 @@
         self._update_index()
         return self._index.has_key(pagename)
 
+    def _get_rules(self):
+        self._prepare_rules()
+        return self._compiled_rules
+    rules = property(_get_rules)
+
+    def _get_helper_patterns(self):
+        self._prepare_rules()
+        return self._helper_patterns
+    helper_patterns = property(_get_helper_patterns)
+
+    def _get_external_handlers(self):
+        self._prepare_rules()
+        return self._external_handlers
+    external_handlers = property(_get_external_handlers)
+    
+    def _prepare_rules(self):
+        from trac.wiki.formatter import Formatter
+        if not self._compiled_rules:
+            helpers = []
+            handlers = {}
+            syntax = Formatter._pre_rules[:]
+            i = 0
+            for resolver in self.syntax_providers:
+                for regexp, handler in resolver.get_wiki_syntax():
+                    handlers['i'+str(i)] = handler
+                    syntax.append('(?P<i%d>%s)' % (i, regexp))
+                    i += 1
+            syntax += Formatter._post_rules[:]
+            helper_re = re.compile(r'\?P<([a-z\d_]+)>')
+            for rule in syntax:
+                helpers += helper_re.findall(rule)[1:]
+            rules = re.compile('(?:' + '|'.join(syntax) + ')')
+            self._external_handlers = handlers
+            self._helper_patterns = helpers
+            self._compiled_rules = rules
+
+    def _get_link_resolvers(self):
+        if not self._link_resolvers:
+            resolvers = {}
+            for resolver in self.syntax_providers:
+                for namespace, handler in resolver.get_link_resolvers():
+                    resolvers[namespace] = handler
+            self._link_resolvers = resolvers
+        return self._link_resolvers
+    link_resolvers = property(_get_link_resolvers)
+
     # IWikiChangeListener methods
 
     def wiki_page_added(self, page):

trac/wiki/formatter.py

@@ -19 +19 @@
 from __future__ import generators
 import re
 import os
-import string
 import urllib
 
 try:
@@ -136 +135 @@
 class Formatter(object):
     flavor = 'default'
 
-    _link_resolvers = None
     # Rules provided by IWikiSyntaxProviders are inserted between pre_rules and post_rules
     _pre_rules = [r"(?P<bolditalic>%s)" % BOLDITALIC_TOKEN,
                   r"(?P<bold>%s)" % BOLD_TOKEN,
@@ -165 +163 @@
                    r"(?P<last_table_cell>\|\|\s*$)",
                    r"(?P<table_cell>\|\|)"]
 
-    _compiled_rules = None
-    _helper_patterns = None
-    _external_handlers = None
     _processor_re = re.compile('#\!([\w+-][\w+-/]*)')
     _anchor_re = re.compile('[^\w\d\.-:]+', re.UNICODE)
     
@@ -194 +189 @@
     db = property(fget=_get_db)
 
     def _get_rules(self):
-        if not Formatter._compiled_rules:
-            helpers = []
-            handlers = {}
-            syntax = Formatter._pre_rules[:]
-            wiki = WikiSystem(self.env)
-            i = 0
-            for resolver in wiki.syntax_providers:
-                for regexp, handler in resolver.get_wiki_syntax():
-                    handlers['i'+str(i)] = handler
-                    syntax.append('(?P<i%d>%s)' % (i, regexp))
-                    i += 1
-            syntax += Formatter._post_rules[:]
-            helper_re = re.compile(r'\?P<([a-z\d]+)>')
-            for rule in syntax:
-                helpers += helper_re.findall(rule)[1:]
-            rules = re.compile('(?:' + string.join(syntax, '|') + ')')
-            Formatter._external_handlers = handlers
-            Formatter._helper_patterns = helpers
-            Formatter._compiled_rules = rules
-        return Formatter._compiled_rules
+        return WikiSystem(self.env).rules
     rules = property(_get_rules)
 
     def _get_link_resolvers(self):
-        if not self._link_resolvers:
-            resolvers = {}
-            wiki = WikiSystem(self.env)
-            for resolver in wiki.syntax_providers:
-                for namespace, handler in resolver.get_link_resolvers():
-                    resolvers[namespace] = handler
-            self._link_resolvers = resolvers
-        return self._link_resolvers
+        return WikiSystem(self.env).link_resolvers
     link_resolvers = property(_get_link_resolvers)
 
     def replace(self, fullmatch):
+        wiki = WikiSystem(self.env)        
         for itype, match in fullmatch.groupdict().items():
-            if match and not itype in Formatter._helper_patterns:
+            if match and not itype in wiki.helper_patterns:
                 # Check for preceding escape character '!'
                 if match[0] == '!':
                     return match[1:]
-                if itype in self._external_handlers:
-                    return self._external_handlers[itype](self, match, fullmatch)
+                if itype in wiki.external_handlers:
+                    return wiki.external_handlers[itype](self, match, fullmatch)
                 else:
                     return getattr(self, '_' + itype + '_formatter')(match, fullmatch)
 
@@ -308 +278 @@
 
     def _make_link(self, ns, target, match, label):
         if ns in self.link_resolvers:
-            return self._link_resolvers[ns](self, ns, target, label)
+            return self.link_resolvers[ns](self, ns, target, label)
         elif target.startswith('//') or ns == "mailto":
             return self._make_ext_link(ns+':'+target, label)
         else:
@@ -342 +312 @@
         if match[0] == '!':
             return match[1:]
         else:
-            return self.simple_tag_handler('<span class="underline">', '</span>')
+            return self.simple_tag_handler('<span class="underline">',
+                                           '</span>')
 
     def _strike_formatter(self, match, fullmatch):
         if match[0] == '!':