Mark regexes as "private"

sebastinas · sebastinas · commit c21753bf74e2 · 2021-05-25T17:56:28.000+02:00
diff --git a/bpython/line.py b/bpython/line.py
@@ -11,15 +11,15 @@
 from .lazyre import LazyReCompile
 
 LinePart = namedtuple("LinePart", ["start", "stop", "word"])
-current_word_re = LazyReCompile(r"(?<![)\]\w_.])" r"([\w_][\w0-9._]*[(]?)")
+_current_word_re = LazyReCompile(r"(?<![)\]\w_.])" r"([\w_][\w0-9._]*[(]?)")
 
 
 def current_word(cursor_offset: int, line: str) -> Optional[LinePart]:
     """the object.attribute.attribute just before or under the cursor"""
     start = cursor_offset
     end = cursor_offset
     word = None
-    for m in current_word_re.finditer(line):
+    for m in _current_word_re.finditer(line):
         if m.start(1) < cursor_offset <= m.end(1):
             start = m.start(1)
             end = m.end(1)
@@ -29,29 +29,29 @@ def current_word(cursor_offset: int, line: str) -> Optional[LinePart]:
     return LinePart(start, end, word)
 
 
-current_dict_key_re = LazyReCompile(r"""[\w_][\w0-9._]*\[([\w0-9._(), '"]*)""")
+_current_dict_key_re = LazyReCompile(r"""[\w_][\w0-9._]*\[([\w0-9._(), '"]*)""")
 
 
 def current_dict_key(cursor_offset: int, line: str) -> Optional[LinePart]:
     """If in dictionary completion, return the current key"""
-    for m in current_dict_key_re.finditer(line):
+    for m in _current_dict_key_re.finditer(line):
         if m.start(1) <= cursor_offset <= m.end(1):
             return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
-current_dict_re = LazyReCompile(r"""([\w_][\w0-9._]*)\[([\w0-9._(), '"]*)""")
+_current_dict_re = LazyReCompile(r"""([\w_][\w0-9._]*)\[([\w0-9._(), '"]*)""")
 
 
 def current_dict(cursor_offset: int, line: str) -> Optional[LinePart]:
     """If in dictionary completion, return the dict that should be used"""
-    for m in current_dict_re.finditer(line):
+    for m in _current_dict_re.finditer(line):
         if m.start(2) <= cursor_offset <= m.end(2):
             return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
-current_string_re = LazyReCompile(
+_current_string_re = LazyReCompile(
     '''(?P<open>(?:""")|"|(?:''\')|')(?:((?P<closed>.+?)(?P=open))|'''
     """(?P<unclosed>.+))"""
 )
@@ -63,14 +63,14 @@ def current_string(cursor_offset: int, line: str) -> Optional[LinePart]:
 
     Weaker than bpython.Repl's current_string, because that checks that a
     string is a string based on previous lines in the buffer."""
-    for m in current_string_re.finditer(line):
+    for m in _current_string_re.finditer(line):
         i = 3 if m.group(3) else 4
         if m.start(i) <= cursor_offset <= m.end(i):
             return LinePart(m.start(i), m.end(i), m.group(i))
     return None
 
 
-current_object_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]")
+_current_object_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]")
 
 
 def current_object(cursor_offset: int, line: str) -> Optional[LinePart]:
@@ -82,15 +82,15 @@ def current_object(cursor_offset: int, line: str) -> Optional[LinePart]:
     start, end, word = match
     s = ".".join(
         m.group(1)
-        for m in current_object_re.finditer(word)
+        for m in _current_object_re.finditer(word)
         if m.end(1) + start < cursor_offset
     )
     if not s:
         return None
     return LinePart(start, start + len(s), s)
 
 
-current_object_attribute_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]?")
+_current_object_attribute_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]?")
 
 
 def current_object_attribute(
@@ -102,15 +102,15 @@ def current_object_attribute(
     if match is None:
         return None
     start, end, word = match
-    matches = current_object_attribute_re.finditer(word)
+    matches = _current_object_attribute_re.finditer(word)
     next(matches)
     for m in matches:
         if m.start(1) + start <= cursor_offset <= m.end(1) + start:
             return LinePart(m.start(1) + start, m.end(1) + start, m.group(1))
     return None
 
 
-current_from_import_from_re = LazyReCompile(
+_current_from_import_from_re = LazyReCompile(
     r"from +([\w0-9_.]*)(?:\s+import\s+([\w0-9_]+[,]?\s*)+)*"
 )
 
@@ -124,17 +124,19 @@ def current_from_import_from(
     parts of an import: from (module) import (name1, name2)
     """
     # TODO allow for as's
-    for m in current_from_import_from_re.finditer(line):
+    for m in _current_from_import_from_re.finditer(line):
         if (m.start(1) < cursor_offset <= m.end(1)) or (
             m.start(2) < cursor_offset <= m.end(2)
         ):
             return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
-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_]*)")
+_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(
@@ -144,15 +146,15 @@ def current_from_import_import(
 
     returns None if cursor not in or just after one of these words
     """
-    baseline = current_from_import_import_re_1.search(line)
+    baseline = _current_from_import_import_re_1.search(line)
     if baseline is None:
         return None
-    match1 = current_from_import_import_re_2.search(line[baseline.end() :])
+    match1 = _current_from_import_import_re_2.search(line[baseline.end() :])
     if match1 is None:
         return None
     for m in chain(
         (match1,),
-        current_from_import_import_re_3.finditer(line[baseline.end() :]),
+        _current_from_import_import_re_3.finditer(line[baseline.end() :]),
     ):
         start = baseline.end() + m.start(1)
         end = baseline.end() + m.end(1)
@@ -161,21 +163,21 @@ def current_from_import_import(
     return None
 
 
-current_import_re_1 = LazyReCompile(r"import")
-current_import_re_2 = LazyReCompile(r"([\w0-9_.]+)")
-current_import_re_3 = LazyReCompile(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: int, line: str) -> Optional[LinePart]:
     # TODO allow for multiple as's
-    baseline = current_import_re_1.search(line)
+    baseline = _current_import_re_1.search(line)
     if baseline is None:
         return None
-    match1 = current_import_re_2.search(line[baseline.end() :])
+    match1 = _current_import_re_2.search(line[baseline.end() :])
     if match1 is None:
         return None
     for m in chain(
-        (match1,), current_import_re_3.finditer(line[baseline.end() :])
+        (match1,), _current_import_re_3.finditer(line[baseline.end() :])
     ):
         start = baseline.end() + m.start(1)
         end = baseline.end() + m.end(1)
@@ -184,25 +186,25 @@ def current_import(cursor_offset: int, line: str) -> Optional[LinePart]:
     return None
 
 
-current_method_definition_name_re = LazyReCompile(r"def\s+([a-zA-Z_][\w]*)")
+_current_method_definition_name_re = LazyReCompile(r"def\s+([a-zA-Z_][\w]*)")
 
 
 def current_method_definition_name(
     cursor_offset: int, line: str
 ) -> Optional[LinePart]:
     """The name of a method being defined"""
-    for m in current_method_definition_name_re.finditer(line):
+    for m in _current_method_definition_name_re.finditer(line):
         if m.start(1) <= cursor_offset <= m.end(1):
             return LinePart(m.start(1), m.end(1), m.group(1))
     return None
 
 
-current_single_word_re = LazyReCompile(r"(?<![.])\b([a-zA-Z_][\w]*)")
+_current_single_word_re = LazyReCompile(r"(?<![.])\b([a-zA-Z_][\w]*)")
 
 
 def current_single_word(cursor_offset: int, line: str) -> Optional[LinePart]:
     """the un-dotted word just before or under the cursor"""
-    for m in current_single_word_re.finditer(line):
+    for m in _current_single_word_re.finditer(line):
         if m.start(1) <= cursor_offset <= m.end(1):
             return LinePart(m.start(1), m.end(1), m.group(1))
     return None
@@ -221,7 +223,7 @@ def current_dotted_attribute(
     return None
 
 
-current_expression_attribute_re = LazyReCompile(
+_current_expression_attribute_re = LazyReCompile(
     r"[.]\s*((?:[\w_][\w0-9_]*)|(?:))"
 )
 
@@ -231,7 +233,7 @@ def current_expression_attribute(
 ) -> Optional[LinePart]:
     """If after a dot, the attribute being completed"""
     # TODO replace with more general current_expression_attribute
-    for m in current_expression_attribute_re.finditer(line):
+    for m in _current_expression_attribute_re.finditer(line):
         if m.start(1) <= cursor_offset <= m.end(1):
             return LinePart(m.start(1), m.end(1), m.group(1))
     return None
