Merge pull request #20298 from ccordoba12/issue-20285

PR: Fix automatic completions after a dot is written next to a module

Author: ccordoba12

spyder/plugins/editor/widgets/base.py

@@ -909,7 +909,8 @@ def select_completion_list(self):
         self.completion_widget.item_selected()
 
     def insert_completion(self, completion, completion_position):
-        """Insert a completion into the editor.
+        """
+        Insert a completion into the editor.
 
         completion_position is where the completion was generated.
 
@@ -944,15 +945,18 @@ def insert_completion(self, completion, completion_position):
                 text = completion['insertText']
             text = to_text_string(text)
 
-            # Get word on the left of the cursor.
-            result = self.get_current_word_and_position(completion=True)
+            # Get word to the left of the cursor.
+            result = self.get_current_word_and_position(
+                completion=True, valid_python_variable=False)
             if result is not None:
                 current_text, start_position = result
                 end_position = start_position + len(current_text)
+
                 # Check if the completion position is in the expected range
                 if not start_position <= completion_position <= end_position:
                     return
                 cursor.setPosition(start_position)
+
                 # Remove the word under the cursor
                 cursor.setPosition(end_position,
                                    QTextCursor.KeepAnchor)

spyder/plugins/editor/widgets/codeeditor.py

@@ -605,9 +605,6 @@ def __init__(self, parent=None):
         self.patch = []
         self.leading_whitespaces = {}
 
-        # re-use parent of completion_widget (usually the main window)
-        completion_parent = self.completion_widget.parent()
-
         # Some events should not be triggered during undo/redo
         # such as line stripping
         self.is_undoing = False
@@ -1523,15 +1520,20 @@ def process_completion(self, params):
 
         try:
             completions = params['params']
-            completions = ([] if completions is None else
-                           [completion for completion in completions
-                            if completion.get('insertText')
-                            or completion.get('textEdit', {}).get('newText')])
-            prefix = self.get_current_word(completion=True,
-                                           valid_python_variable=False)
-            if (len(completions) == 1
-                    and completions[0].get('insertText') == prefix
-                    and not completions[0].get('textEdit', {}).get('newText')):
+            completions = (
+                [] if completions is None else
+                [completion for completion in completions
+                 if completion.get('insertText')
+                 or completion.get('textEdit', {}).get('newText')]
+            )
+            prefix = self.get_current_word(
+                completion=True, valid_python_variable=False)
+
+            if (
+                len(completions) == 1 and
+                completions[0].get('insertText') == prefix and
+                not completions[0].get('textEdit', {}).get('newText')
+            ):
                 completions.pop()
 
             replace_end = self.textCursor().position()
@@ -1550,12 +1552,14 @@ def sort_key(completion):
                     text_insertion = completion['textEdit']['newText']
                 else:
                     text_insertion = completion['insertText']
+
                 first_insert_letter = text_insertion[0]
                 case_mismatch = (
                     (first_letter.isupper() and first_insert_letter.islower())
                     or
                     (first_letter.islower() and first_insert_letter.isupper())
                 )
+
                 # False < True, so case matches go first
                 return (case_mismatch, completion['sortText'])
 
@@ -1568,8 +1572,11 @@ def sort_key(completion):
                 if 'textEdit' in completion:
                     c_replace_start = completion['textEdit']['range']['start']
                     c_replace_end = completion['textEdit']['range']['end']
-                    if (c_replace_start == replace_start
-                            and c_replace_end == replace_end):
+
+                    if (
+                        c_replace_start == replace_start and
+                        c_replace_end == replace_end
+                    ):
                         insert_text = completion['textEdit']['newText']
                         completion['filterText'] = insert_text
                         completion['insertText'] = insert_text
@@ -4766,8 +4773,11 @@ def keyPressEvent(self, event):
                 self.completion_widget.hide()
         if key in (Qt.Key_Enter, Qt.Key_Return):
             if not shift and not ctrl:
-                if (self.add_colons_enabled and self.is_python_like() and
-                        self.autoinsert_colons()):
+                if (
+                    self.add_colons_enabled and
+                    self.is_python_like() and
+                    self.autoinsert_colons()
+                ):
                     self.textCursor().beginEditBlock()
                     self.insert_text(':' + self.get_line_separator())
                     if self.strip_trailing_spaces_on_modify:
@@ -4815,16 +4825,21 @@ def keyPressEvent(self, event):
                 trailing_spaces = leading_length - len(leading_text.rstrip())
                 trailing_text = self.get_text('cursor', 'eol')
                 matches = ('()', '[]', '{}', '\'\'', '""')
-                if (not leading_text.strip() and
-                        (leading_length > len(self.indent_chars))):
+                if (
+                    not leading_text.strip() and
+                    (leading_length > len(self.indent_chars))
+                ):
                     if leading_length % len(self.indent_chars) == 0:
                         self.unindent()
                     else:
                         self._handle_keypress_event(event)
                 elif trailing_spaces and not trailing_text.strip():
                     self.remove_suffix(leading_text[-trailing_spaces:])
-                elif (leading_text and trailing_text and
-                        (leading_text[-1] + trailing_text[0] in matches)):
+                elif (
+                    leading_text and
+                    trailing_text and
+                    (leading_text[-1] + trailing_text[0] in matches)
+                ):
                     cursor = self.textCursor()
                     cursor.movePosition(QTextCursor.PreviousCharacter)
                     cursor.movePosition(QTextCursor.NextCharacter,
@@ -4839,27 +4854,36 @@ def keyPressEvent(self, event):
             # redefine this basic action which should have been implemented
             # natively
             self.stdkey_end(shift, ctrl)
-        elif (text in self.auto_completion_characters and
-                self.automatic_completions):
+        elif (
+            text in self.auto_completion_characters and
+            self.automatic_completions
+        ):
             self.insert_text(text)
             if text == ".":
                 if not self.in_comment_or_string():
                     text = self.get_text('sol', 'cursor')
                     last_obj = getobj(text)
                     prev_char = text[-2] if len(text) > 1 else ''
-                    if (prev_char in {')', ']', '}'} or
-                            (last_obj and not last_obj.isdigit())):
+                    if (
+                        prev_char in {')', ']', '}'} or
+                        (last_obj and not last_obj.isdigit())
+                    ):
                         # Completions should be triggered immediately when
                         # an autocompletion character is introduced.
                         self.do_completion(automatic=True)
             else:
                 self.do_completion(automatic=True)
-        elif (text in self.signature_completion_characters and
-                not self.has_selected_text()):
+        elif (
+            text in self.signature_completion_characters and
+            not self.has_selected_text()
+        ):
             self.insert_text(text)
             self.request_signature()
-        elif (key == Qt.Key_Colon and not has_selection and
-                self.auto_unindent_enabled):
+        elif (
+            key == Qt.Key_Colon and
+            not has_selection and
+            self.auto_unindent_enabled
+        ):
             leading_text = self.get_text('sol', 'cursor')
             if leading_text.lstrip() in ('else', 'finally'):
                 ind = lambda txt: len(txt) - len(txt.lstrip())
@@ -4870,8 +4894,13 @@ def keyPressEvent(self, event):
                 if ind(leading_text) == ind(prevtxt):
                     self.unindent(force=True)
             self._handle_keypress_event(event)
-        elif (key == Qt.Key_Space and not shift and not ctrl and not
-                has_selection and self.auto_unindent_enabled):
+        elif (
+            key == Qt.Key_Space and
+            not shift and
+            not ctrl and
+            not has_selection and
+            self.auto_unindent_enabled
+        ):
             self.completion_widget.hide()
             leading_text = self.get_text('sol', 'cursor')
             if leading_text.lstrip() in ('elif', 'except'):
@@ -4956,13 +4985,20 @@ def do_automatic_completions(self):
         is_backspace = (
             self.is_completion_widget_visible() and key == Qt.Key_Backspace)
 
-        if (len(text) >= self.automatic_completions_after_chars
-                and self._last_key_pressed_text or is_backspace):
+        if (
+            (len(text) >= self.automatic_completions_after_chars) and
+            self._last_key_pressed_text or
+            is_backspace
+        ):
             # Perform completion on the fly
             if not self.in_comment_or_string():
                 # Variables can include numbers and underscores
-                if (text.isalpha() or text.isalnum() or '_' in text
-                        or '.' in text):
+                if (
+                    text.isalpha() or
+                    text.isalnum() or
+                    '_' in text
+                    or '.' in text
+                ):
                     self.do_completion(automatic=True)
                     self._last_key_pressed_text = ''
                     self._last_pressed_key = None

spyder/plugins/editor/widgets/tests/test_introspection.py

@@ -23,6 +23,10 @@
 # Local imports
 from spyder.config.base import running_in_ci, running_in_ci_with_conda
 from spyder.config.utils import is_anaconda
+from spyder.plugins.completion.api import (
+    CompletionRequestTypes, CompletionItemKind)
+from spyder.plugins.completion.providers.languageserver.providers.utils import (
+    path_as_uri)
 from spyder.plugins.completion.providers.kite.utils.status import (
     check_if_kite_installed, check_if_kite_running)
 from spyder.py3compat import PY2
@@ -1178,5 +1182,75 @@ def test_completions_environment(completions_codeeditor, qtbot, tmpdir):
     completion_plugin.after_configuration_update([])
 
 
+@pytest.mark.slow
+@pytest.mark.order(1)
+@flaky(max_runs=5)
+def test_dot_completions(completions_codeeditor, qtbot):
+    """
+    Test that completions after a dot are working as expected.
+
+    This is a regression test for issue spyder-ide/spyder#20285
+    """
+    code_editor, _ = completions_codeeditor
+    completion = code_editor.completion_widget
+
+    # Import module and check completions are shown for it after writing a dot
+    # after it
+    qtbot.keyClicks(code_editor, "import math")
+    qtbot.keyPress(code_editor, Qt.Key_Enter)
+
+    qtbot.wait(500)
+    assert not completion.isVisible()
+
+    with qtbot.waitSignal(completion.sig_show_completions, timeout=10000):
+        qtbot.keyClicks(code_editor, "math.")
+
+    qtbot.wait(500)
+    assert completion.isVisible()
+
+
+@pytest.mark.slow
+@pytest.mark.order(1)
+def test_completions_for_files_that_start_with_numbers(
+        mock_completions_codeeditor, qtbot):
+    """
+    Test that completions for files that start with numbers are handled as
+    expected.
+
+    This is a regression test for issue spyder-ide/spyder#20156
+    """
+    code_editor, mock_response = mock_completions_codeeditor
+    completion = code_editor.completion_widget
+    file_name = '000_testing.txt'
+
+    # Set text to complete and move cursor to the position we want to ask for
+    # completions.
+    qtbot.keyClicks(code_editor, "'0'")
+    code_editor.moveCursor(QTextCursor.PreviousCharacter)
+    qtbot.wait(500)
+
+    # Complete '0' -> '000_testing.txt'
+    mock_response.side_effect = lambda lang, method, params: {'params': [{
+        'label': f'{file_name}',
+        'kind': CompletionItemKind.FILE,
+        'sortText': (0, f'a{file_name}'),
+        'insertText': f'{file_name}',
+        'data': {'doc_uri': path_as_uri(__file__)},
+        'detail': '',
+        'documentation': '',
+        'filterText': f'{file_name}',
+        'insertTextFormat': 1,
+        'provider': 'LSP',
+        'resolve': True
+    }]} if method == CompletionRequestTypes.DOCUMENT_COMPLETION else None
+
+    with qtbot.waitSignal(completion.sig_show_completions,
+                          timeout=10000):
+        qtbot.keyPress(code_editor, Qt.Key_Tab, delay=300)
+
+    qtbot.wait(500)
+    assert code_editor.get_text_with_eol() == f"'{file_name}'"
+
+
 if __name__ == '__main__':
     pytest.main(['test_introspection.py', '--run-slow'])

spyder/widgets/mixins.py

@@ -1083,7 +1083,7 @@ def is_special_character(move):
         startpos = cursor.selectionStart()
 
         # Find a valid Python variable name
-        if valid_python_variable and not completion:
+        if valid_python_variable:
             match = re.findall(r'([^\d\W]\w*)', text, re.UNICODE)
             if not match:
                 # This is assumed in several places of our codebase,