Lazy compile all regex

sebastinas · sebastinas · commit 3db074b0ad8a · 2015-02-01T00:24:31.000+01:00
Signed-off-by: Sebastian Ramacher &lt;sebastian+dev@ramacher.at&gt;
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -26,7 +26,6 @@
 import abc
 import keyword
 import os
-import re
 import rlcompleter
 
 from glob import glob
@@ -461,17 +460,13 @@ def safe_eval(expr, namespace):
         raise EvaluationError
 
 
-attr_matches_re = None
+attr_matches_re = lineparts.LazyReCompile(r"(\w+(\.\w+)*)\.(\w*)")
 
 
 def attr_matches(text, namespace):
     """Taken from rlcompleter.py and bent to my will.
     """
 
-    global attr_matches_re
-    if attr_matches_re is None:
-        attr_matches_re = re.compile(r"(\w+(\.\w+)*)\.(\w*)")
-
     # Gna, Py 2.6's rlcompleter searches for __call__ inside the
     # instance instead of the type, so we monkeypatch to prevent
     # side-effects (__getattr__/__getattribute__)
diff --git a/bpython/line.py b/bpython/line.py
@@ -7,7 +7,34 @@
 from itertools import chain
 
 
-current_word_re = re.compile(r'[\w_][\w0-9._]*[(]?')
+class LazyReCompile(object):
+
+    def __init__(self, regex):
+        self.regex = regex
+        self.compiled = None
+
+    def compile_regex(method):
+        def _impl(self, *args, **kwargs):
+            if self.compiled is None:
+                self.compiled = re.compile(self.regex)
+            return method(self, *args, **kwargs)
+        return _impl
+
+    @compile_regex
+    def finditer(self, *args, **kwargs):
+        return self.compiled.finditer(*args, **kwargs)
+
+    @compile_regex
+    def search(self, *args, **kwargs):
+        return self.compiled.search(*args, **kwargs)
+
+    @compile_regex
+    def match(self, *args, **kwargs):
+        return self.compiled.match(*args, **kwargs)
+
+
+current_word_re = LazyReCompile(r'[\w_][\w0-9._]*[(]?')
+
 
 def current_word(cursor_offset, line):
     """the object.attribute.attribute just before or under the cursor"""
@@ -26,7 +53,7 @@ def current_word(cursor_offset, line):
     return (start, end, word)
 
 
-current_dict_key_re = re.compile(r'''[\w_][\w0-9._]*\[([\w0-9._(), '"]*)''')
+current_dict_key_re = LazyReCompile(r'''[\w_][\w0-9._]*\[([\w0-9._(), '"]*)''')
 
 def current_dict_key(cursor_offset, line):
     """If in dictionary completion, return the current key"""
@@ -37,7 +64,8 @@ def current_dict_key(cursor_offset, line):
     return None
 
 
-current_dict_re = re.compile(r'''([\w_][\w0-9._]*)\[([\w0-9._(), '"]*)''')
+current_dict_re = LazyReCompile(r'''([\w_][\w0-9._]*)\[([\w0-9._(), '"]*)''')
+
 
 def current_dict(cursor_offset, line):
     """If in dictionary completion, return the dict that should be used"""
@@ -48,9 +76,10 @@ def current_dict(cursor_offset, line):
     return None
 
 
-current_string_re = re.compile(
+current_string_re = LazyReCompile(
     '''(?P<open>(?:""")|"|(?:''\')|')(?:((?P<closed>.+?)(?P=open))|(?P<unclosed>.+))''')
 
+
 def current_string(cursor_offset, line):
     """If inside a string of nonzero length, return the string (excluding quotes)
 
@@ -63,7 +92,7 @@ def current_string(cursor_offset, line):
     return None
 
 
-current_object_re = re.compile(r'([\w_][\w0-9_]*)[.]')
+current_object_re = LazyReCompile(r'([\w_][\w0-9_]*)[.]')
 
 def current_object(cursor_offset, line):
     """If in attribute completion, the object on which attribute should be looked up"""
@@ -82,7 +111,7 @@ def current_object(cursor_offset, line):
     return start, start+len(s), s
 
 
-current_object_attribute_re = re.compile(r'([\w_][\w0-9_]*)[.]?')
+current_object_attribute_re = LazyReCompile(r'([\w_][\w0-9_]*)[.]?')
 
 def current_object_attribute(cursor_offset, line):
     """If in attribute completion, the attribute being completed"""
@@ -97,7 +126,7 @@ def current_object_attribute(cursor_offset, line):
     return None
 
 
-current_from_import_from_re = re.compile(r'from ([\w0-9_.]*)(?:\s+import\s+([\w0-9_]+[,]?\s*)+)*')
+current_from_import_from_re = LazyReCompile(r'from ([\w0-9_.]*)(?:\s+import\s+([\w0-9_]+[,]?\s*)+)*')
 
 def current_from_import_from(cursor_offset, line):
     """If in from import completion, the word after from
@@ -117,9 +146,9 @@ def current_from_import_from(cursor_offset, line):
     return None
 
 
-current_from_import_import_re_1 = re.compile(r'from\s([\w0-9_.]*)\s+import')
-current_from_import_import_re_2 = re.compile(r'([\w0-9_]+)')
-current_from_import_import_re_3 = re.compile(r'[,][ ]([\w0-9_]*)')
+current_from_import_import_re_1 = LazyReCompile(r'from\s([\w0-9_.]*)\s+import')
+current_from_import_import_re_2 = LazyReCompile(r'([\w0-9_]+)')
+current_from_import_import_re_3 = LazyReCompile(r'[,][ ]([\w0-9_]*)')
 
 def current_from_import_import(cursor_offset, line):
     """If in from import completion, the word after import being completed
@@ -141,9 +170,9 @@ def current_from_import_import(cursor_offset, line):
     return None
 
 
-current_import_re_1 = re.compile(r'import')
-current_import_re_2 = re.compile(r'([\w0-9_.]+)')
-current_import_re_3 = re.compile(r'[,][ ]([\w0-9_.]*)')
+current_import_re_1 = LazyReCompile(r'import')
+current_import_re_2 = LazyReCompile(r'([\w0-9_.]+)')
+current_import_re_3 = LazyReCompile(r'[,][ ]([\w0-9_.]*)')
 
 def current_import(cursor_offset, line):
     #TODO allow for multiple as's
@@ -161,7 +190,7 @@ def current_import(cursor_offset, line):
             return start, end, m.group(1)
 
 
-current_method_definition_name_re = re.compile("def\s+([a-zA-Z_][\w]*)")
+current_method_definition_name_re = LazyReCompile("def\s+([a-zA-Z_][\w]*)")
 
 def current_method_definition_name(cursor_offset, line):
     """The name of a method being defined"""
@@ -172,7 +201,7 @@ def current_method_definition_name(cursor_offset, line):
     return None
 
 
-current_single_word_re = re.compile(r"(?<![.])\b([a-zA-Z_][\w]*)")
+current_single_word_re = LazyReCompile(r"(?<![.])\b([a-zA-Z_][\w]*)")
 
 def current_single_word(cursor_offset, line):
     """the un-dotted word just before or under the cursor"""
@@ -192,7 +221,7 @@ def current_dotted_attribute(cursor_offset, line):
         return start, end, word
 
 
-current_string_literal_attr_re = re.compile(
+current_string_literal_attr_re = LazyReCompile(
     "('''" +
     r'''|"""|'|")((?:(?=([^"'\\]+|\\.|(?!\1)["']))\3)*)\1[.]([a-zA-Z_]?[\w]*)''')
 
