Re-introduce autocompletion modes

sebastinas · sebastinas · commit 2cfa83b1fb13 · 2015-03-16T04:01:03.000+01:00
Signed-off-by: Sebastian Ramacher &lt;sebastian+dev@ramacher.at&gt;
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -68,11 +68,32 @@ def after_last_dot(name):
     return name.rstrip('.').rsplit('.')[-1]
 
 
+def method_match_simple(word, size, text):
+    return word[:size] == text
+
+
+def method_match_substring(word, size, text):
+    return text in word
+
+
+def method_match_fuzzy(word, size, text):
+    s = r'.*%s.*' % '.*'.join(list(text))
+    return re.search(s, word)
+
+
+MODES_MAP = {
+    SIMPLE: method_match_simple,
+    SUBSTRING: method_match_substring,
+    FUZZY: method_match_fuzzy
+}
+
+
 class BaseCompletionType(object):
     """Describes different completion types"""
 
-    def __init__(self, shown_before_tab=True):
+    def __init__(self, shown_before_tab=True, mode=SIMPLE):
         self._shown_before_tab = shown_before_tab
+        self.method_match = MODES_MAP[mode]
 
     def matches(self, cursor_offset, line, **kwargs):
         """Returns a list of possible matches given a line and cursor, or None
@@ -112,17 +133,20 @@ def shown_before_tab(self):
         once that has happened."""
         return self._shown_before_tab
 
+    def method_match(self, word, size, text):
+        return word[:size] == text
+
 
 class CumulativeCompleter(BaseCompletionType):
     """Returns combined matches from several completers"""
 
-    def __init__(self, completers):
+    def __init__(self, completers, mode=SIMPLE):
         if not completers:
             raise ValueError(
                 "CumulativeCompleter requires at least one completer")
         self._completers = completers
 
-        super(CumulativeCompleter, self).__init__(True)
+        super(CumulativeCompleter, self).__init__(True, mode)
 
     def locate(self, current_offset, line):
         return self._completers[0].locate(current_offset, line)
@@ -158,8 +182,8 @@ def format(self, word):
 
 class FilenameCompletion(BaseCompletionType):
 
-    def __init__(self):
-        super(FilenameCompletion, self).__init__(False)
+    def __init__(self, mode=SIMPLE):
+        super(FilenameCompletion, self).__init__(False, mode)
 
     if sys.version_info[:2] >= (3, 4):
         def safe_glob(self, pathname):
@@ -282,7 +306,7 @@ def attr_lookup(self, obj, expr, attr):
         matches = []
         n = len(attr)
         for word in words:
-            if method_match(word, n, attr) and word != "__builtins__":
+            if self.method_match(word, n, attr) and word != "__builtins__":
                 matches.append("%s.%s" % (expr, word))
         return matches
 
@@ -354,11 +378,11 @@ def matches(self, cursor_offset, line, **kwargs):
         matches = set()
         n = len(text)
         for word in KEYWORDS:
-            if method_match(word, n, text):
+            if self.method_match(word, n, text):
                 matches.add(word)
         for nspace in (builtins.__dict__, locals_):
             for word, val in iteritems(nspace):
-                if method_match(word, n, text) and word != "__builtins__":
+                if self.method_match(word, n, text) and word != "__builtins__":
                     word = try_decode(word, 'ascii')
                     # if identifier isn't ascii, don't complete (syntax error)
                     if word is None:
@@ -508,28 +532,31 @@ def get_completer(completers, cursor_offset, line, **kwargs):
     """
 
     for completer in completers:
-        matches = completer.matches(
-            cursor_offset, line, **kwargs)
+        matches = completer.matches(cursor_offset, line, **kwargs)
         if matches is not None:
             return sorted(matches), (completer if matches else None)
     return [], None
 
 
-BPYTHON_COMPLETER = (
-    DictKeyCompletion(),
-    StringLiteralAttrCompletion(),
-    ImportCompletion(),
-    FilenameCompletion(),
-    MagicMethodCompletion(),
-    MultilineJediCompletion(),
-    GlobalCompletion(),
-    CumulativeCompleter((AttrCompletion(), ParameterNameCompletion()))
-)
+def get_default_completer(mode=SIMPLE):
+    return (
+        DictKeyCompletion(mode=mode),
+        StringLiteralAttrCompletion(mode=mode),
+        ImportCompletion(mode=mode),
+        FilenameCompletion(mode=mode),
+        MagicMethodCompletion(mode=mode),
+        MultilineJediCompletion(mode=mode),
+        GlobalCompletion(mode=mode),
+        CumulativeCompleter((AttrCompletion(mode=mode),
+                             ParameterNameCompletion(mode=mode)),
+                            mode=mode)
+    )
 
 
 def get_completer_bpython(cursor_offset, line, **kwargs):
     """"""
-    return get_completer(BPYTHON_COMPLETER, cursor_offset, line, **kwargs)
+    return get_completer(get_default_completer(),
+                         cursor_offset, line, **kwargs)
 
 
 class EvaluationError(Exception):
@@ -552,7 +579,3 @@ def _callable_postfix(value, word):
         if inspection.is_callable(value):
             word += '('
     return word
-
-
-def method_match(word, size, text):
-    return word[:size] == text
diff --git a/bpython/repl.py b/bpython/repl.py
@@ -384,6 +384,9 @@ def __init__(self, interp, config):
             except EnvironmentError:
                 pass
 
+        self.completers = autocomplete.get_default_completer(
+            config.autocomplete_mode)
+
     @property
     def ps1(self):
         try:
@@ -595,7 +598,8 @@ def complete(self, tab=False):
 
         self.set_docstring()
 
-        matches, completer = autocomplete.get_completer_bpython(
+        matches, completer = autocomplete.get_completer(
+            self.completers,
             cursor_offset=self.cursor_offset,
             line=self.current_line,
             locals_=self.interp.locals,
