'
+ '{} ({} {})'
+ )
+
+ msglist = []
+ max_lines_msglist = 25
+ sorted_code_analysis = sorted(code_analysis, key=lambda i: i[2])
+ for src, code, sev, msg in sorted_code_analysis:
+ if src == 'pylint' and '[' in msg and ']' in msg:
+ # Remove extra redundant info from pylint messages
+ msg = msg.split(']')[-1]
+
+ msg = msg.strip()
+ # Avoid messing TODO, FIXME
+ # Prevent error if msg only has one element
+ if len(msg) > 1:
+ msg = msg[0].upper() + msg[1:]
+
+ # Get individual lines following paragraph format and handle
+ # symbols like '<' and '>' to not mess with br tags
+ msg = msg.replace('<', '<').replace('>', '>')
+ paragraphs = msg.splitlines()
+ new_paragraphs = []
+ long_paragraphs = 0
+ lines_per_message = 6
+ for paragraph in paragraphs:
+ new_paragraph = textwrap.wrap(
+ paragraph,
+ width=self._DEFAULT_MAX_HINT_WIDTH)
+ if lines_per_message > 2:
+ if len(new_paragraph) > 1:
+ new_paragraph = ''.join(new_paragraph[:2]) + '...' + long_paragraphs += 1 + lines_per_message -= 2 + else: + new_paragraph = '
'.join(new_paragraph) + lines_per_message -= 1 + new_paragraphs.append(new_paragraph) + + if len(new_paragraphs) > 1: + # Define max lines taking into account that in the same + # tooltip you can find multiple warnings and messages + # and each one can have multiple lines + if long_paragraphs != 0: + max_lines = 3 + max_lines_msglist -= max_lines * 2 + else: + max_lines = 5 + max_lines_msglist -= max_lines + msg = '
'.join(new_paragraphs[:max_lines]) + '
' + else: + msg = '
'.join(new_paragraphs) + + base_64 = ima.base64_from_icon(icons[sev], size, size) + if max_lines_msglist >= 0: + msglist.append(template.format(base_64, msg, src, + code, size=size)) + + if msglist: + self.show_tooltip( + title=_("Code analysis"), + text='\n'.join(msglist), + title_color=QStylePalette.COLOR_ACCENT_4, + at_line=line_number, + with_html_format=True + ) + self.highlight_line_warning(block_data) + + def highlight_line_warning(self, block_data): + """Highlight errors and warnings in this editor.""" + self.clear_extra_selections('code_analysis_highlight') + self.highlight_selection('code_analysis_highlight', + block_data._selection(), + background_color=block_data.color) + self.linenumberarea.update() + + def get_current_warnings(self): + """ + Get all warnings for the current editor and return + a list with the message and line number. + """ + block = self.document().firstBlock() + line_count = self.document().blockCount() + warnings = [] + while True: + data = block.userData() + if data and data.code_analysis: + for warning in data.code_analysis: + warnings.append([warning[-1], block.blockNumber() + 1]) + # See spyder-ide/spyder#9924 + if block.blockNumber() + 1 == line_count: + break + block = block.next() + return warnings + + def go_to_next_warning(self): + """ + Go to next code warning message and return new cursor position. + """ + block = self.textCursor().block() + line_count = self.document().blockCount() + for __ in range(line_count): + line_number = block.blockNumber() + 1 + if line_number < line_count: + block = block.next() + else: + block = self.document().firstBlock() + + data = block.userData() + if data and data.code_analysis: + line_number = block.blockNumber() + 1 + self.go_to_line(line_number) + self.show_code_analysis_results(line_number, data) + return self.get_position('cursor') + + def go_to_previous_warning(self): + """ + Go to previous code warning message and return new cursor position. + """ + block = self.textCursor().block() + line_count = self.document().blockCount() + for __ in range(line_count): + line_number = block.blockNumber() + 1 + if line_number > 1: + block = block.previous() + else: + block = self.document().lastBlock() + + data = block.userData() + if data and data.code_analysis: + line_number = block.blockNumber() + 1 + self.go_to_line(line_number) + self.show_code_analysis_results(line_number, data) + return self.get_position('cursor') + + def cell_list(self): + """Get the outline explorer data for all cells.""" + for oedata in self.outlineexplorer_data_list(): + if oedata.def_type == OED.CELL: + yield oedata + + def get_cell_code(self, cell): + """ + Get cell code for a given cell. + + If the cell doesn't exist, raises an exception + """ + selected_block = None + if is_string(cell): + for oedata in self.cell_list(): + if oedata.def_name == cell: + selected_block = oedata.block + break + else: + if cell == 0: + selected_block = self.document().firstBlock() + else: + cell_list = list(self.cell_list()) + if cell <= len(cell_list): + selected_block = cell_list[cell - 1].block + + if not selected_block: + raise RuntimeError("Cell {} not found.".format(repr(cell))) + + cursor = QTextCursor(selected_block) + text, _, off_pos, col_pos = self.get_cell_as_executable_code(cursor) + return text + + def get_cell_code_and_position(self, cell): + """ + Get code and position for a given cell. + + If the cell doesn't exist, raise an exception. + """ + selected_block = None + if is_string(cell): + for oedata in self.cell_list(): + if oedata.def_name == cell: + selected_block = oedata.block + break + else: + if cell == 0: + selected_block = self.document().firstBlock() + else: + cell_list = list(self.cell_list()) + if cell <= len(cell_list): + selected_block = cell_list[cell - 1].block + + if not selected_block: + raise RuntimeError("Cell {} not found.".format(repr(cell))) + + cursor = QTextCursor(selected_block) + text, _, off_pos, col_pos = self.get_cell_as_executable_code(cursor) + return text, off_pos, col_pos + + def get_cell_count(self): + """Get number of cells in document.""" + return 1 + len(list(self.cell_list())) + + # ---- Tasks management + # ------------------------------------------------------------------------- + def go_to_next_todo(self): + """Go to next todo and return new cursor position""" + block = self.textCursor().block() + line_count = self.document().blockCount() + while True: + if block.blockNumber()+1 < line_count: + block = block.next() + else: + block = self.document().firstBlock() + data = block.userData() + if data and data.todo: + break + line_number = block.blockNumber()+1 + self.go_to_line(line_number) + self.show_tooltip( + title=_("To do"), + text=data.todo, + title_color=QStylePalette.COLOR_ACCENT_4, + at_line=line_number, + ) + + return self.get_position('cursor') + + def process_todo(self, todo_results): + """Process todo finder results""" + for data in self.blockuserdata_list(): + data.todo = '' + + for message, line_number in todo_results: + block = self.document().findBlockByNumber(line_number - 1) + data = block.userData() + if not data: + data = BlockUserData(self) + data.todo = message + block.setUserData(data) + self.sig_flags_changed.emit() + + # ---- Comments/Indentation + # ------------------------------------------------------------------------- + def add_prefix(self, prefix): + """Add prefix to current line or selected line(s)""" + cursor = self.textCursor() + if self.has_selected_text(): + # Add prefix to selected line(s) + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + + # Let's see if selection begins at a block start + first_pos = min([start_pos, end_pos]) + first_cursor = self.textCursor() + first_cursor.setPosition(first_pos) + + cursor.beginEditBlock() + cursor.setPosition(end_pos) + # Check if end_pos is at the start of a block: if so, starting + # changes from the previous block + if cursor.atBlockStart(): + cursor.movePosition(QTextCursor.PreviousBlock) + if cursor.position() < start_pos: + cursor.setPosition(start_pos) + move_number = self.__spaces_for_prefix() + + while cursor.position() >= start_pos: + cursor.movePosition(QTextCursor.StartOfBlock) + line_text = to_text_string(cursor.block().text()) + if (self.get_character(cursor.position()) == ' ' + and '#' in prefix and not line_text.isspace() + or (not line_text.startswith(' ') + and line_text != '')): + cursor.movePosition(QTextCursor.Right, + QTextCursor.MoveAnchor, + move_number) + cursor.insertText(prefix) + elif '#' not in prefix: + cursor.insertText(prefix) + if cursor.blockNumber() == 0: + # Avoid infinite loop when indenting the very first line + break + cursor.movePosition(QTextCursor.PreviousBlock) + cursor.movePosition(QTextCursor.EndOfBlock) + cursor.endEditBlock() + else: + # Add prefix to current line + cursor.beginEditBlock() + cursor.movePosition(QTextCursor.StartOfBlock) + if self.get_character(cursor.position()) == ' ' and '#' in prefix: + cursor.movePosition(QTextCursor.NextWord) + cursor.insertText(prefix) + cursor.endEditBlock() + + def __spaces_for_prefix(self): + """Find the less indented level of text.""" + cursor = self.textCursor() + if self.has_selected_text(): + # Add prefix to selected line(s) + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + + # Let's see if selection begins at a block start + first_pos = min([start_pos, end_pos]) + first_cursor = self.textCursor() + first_cursor.setPosition(first_pos) + + cursor.beginEditBlock() + cursor.setPosition(end_pos) + # Check if end_pos is at the start of a block: if so, starting + # changes from the previous block + if cursor.atBlockStart(): + cursor.movePosition(QTextCursor.PreviousBlock) + if cursor.position() < start_pos: + cursor.setPosition(start_pos) + + number_spaces = -1 + while cursor.position() >= start_pos: + cursor.movePosition(QTextCursor.StartOfBlock) + line_text = to_text_string(cursor.block().text()) + start_with_space = line_text.startswith(' ') + left_number_spaces = self.__number_of_spaces(line_text) + if not start_with_space: + left_number_spaces = 0 + if ((number_spaces == -1 + or number_spaces > left_number_spaces) + and not line_text.isspace() and line_text != ''): + number_spaces = left_number_spaces + if cursor.blockNumber() == 0: + # Avoid infinite loop when indenting the very first line + break + cursor.movePosition(QTextCursor.PreviousBlock) + cursor.movePosition(QTextCursor.EndOfBlock) + cursor.endEditBlock() + return number_spaces + + def remove_suffix(self, suffix): + """ + Remove suffix from current line (there should not be any selection) + """ + cursor = self.textCursor() + cursor.setPosition(cursor.position() - qstring_length(suffix), + QTextCursor.KeepAnchor) + if to_text_string(cursor.selectedText()) == suffix: + cursor.removeSelectedText() + + def remove_prefix(self, prefix): + """Remove prefix from current line or selected line(s)""" + cursor = self.textCursor() + if self.has_selected_text(): + # Remove prefix from selected line(s) + start_pos, end_pos = sorted([cursor.selectionStart(), + cursor.selectionEnd()]) + cursor.setPosition(start_pos) + if not cursor.atBlockStart(): + cursor.movePosition(QTextCursor.StartOfBlock) + start_pos = cursor.position() + cursor.beginEditBlock() + cursor.setPosition(end_pos) + # Check if end_pos is at the start of a block: if so, starting + # changes from the previous block + if cursor.atBlockStart(): + cursor.movePosition(QTextCursor.PreviousBlock) + if cursor.position() < start_pos: + cursor.setPosition(start_pos) + + cursor.movePosition(QTextCursor.StartOfBlock) + old_pos = None + while cursor.position() >= start_pos: + new_pos = cursor.position() + if old_pos == new_pos: + break + else: + old_pos = new_pos + line_text = to_text_string(cursor.block().text()) + self.__remove_prefix(prefix, cursor, line_text) + cursor.movePosition(QTextCursor.PreviousBlock) + cursor.endEditBlock() + else: + # Remove prefix from current line + cursor.movePosition(QTextCursor.StartOfBlock) + line_text = to_text_string(cursor.block().text()) + self.__remove_prefix(prefix, cursor, line_text) + + def __remove_prefix(self, prefix, cursor, line_text): + """Handle the removal of the prefix for a single line.""" + cursor.movePosition(QTextCursor.Right, + QTextCursor.MoveAnchor, + line_text.find(prefix)) + # Handle prefix remove for comments with spaces + if (prefix.strip() and line_text.lstrip().startswith(prefix + ' ') + or line_text.startswith(prefix + ' ') and '#' in prefix): + cursor.movePosition(QTextCursor.Right, + QTextCursor.KeepAnchor, len(prefix + ' ')) + # Check for prefix without space + elif (prefix.strip() and line_text.lstrip().startswith(prefix) + or line_text.startswith(prefix)): + cursor.movePosition(QTextCursor.Right, + QTextCursor.KeepAnchor, len(prefix)) + cursor.removeSelectedText() + + def __even_number_of_spaces(self, line_text, group=0): + """ + Get if there is a correct indentation from a group of spaces of a line. + """ + spaces = re.findall(r'\s+', line_text) + if len(spaces) - 1 >= group: + return len(spaces[group]) % len(self.indent_chars) == 0 + + def __number_of_spaces(self, line_text, group=0): + """Get the number of spaces from a group of spaces in a line.""" + spaces = re.findall(r'\s+', line_text) + if len(spaces) - 1 >= group: + return len(spaces[group]) + + def __get_brackets(self, line_text, closing_brackets=[]): + """ + Return unmatched opening brackets and left-over closing brackets. + + (str, []) -> ([(pos, bracket)], [bracket], comment_pos) + + Iterate through line_text to find unmatched brackets. + + Returns three objects as a tuple: + 1) bracket_stack: + a list of tuples of pos and char of each unmatched opening bracket + 2) closing brackets: + this line's unmatched closing brackets + arg closing_brackets. + If this line ad no closing brackets, arg closing_brackets might + be matched with previously unmatched opening brackets in this line. + 3) Pos at which a # comment begins. -1 if it doesn't.' + """ + # Remove inline comment and check brackets + bracket_stack = [] # list containing this lines unmatched opening + # same deal, for closing though. Ignore if bracket stack not empty, + # since they are mismatched in that case. + bracket_unmatched_closing = [] + comment_pos = -1 + deactivate = None + escaped = False + pos, c = None, None + for pos, c in enumerate(line_text): + # Handle '\' inside strings + if escaped: + escaped = False + # Handle strings + elif deactivate: + if c == deactivate: + deactivate = None + elif c == "\\": + escaped = True + elif c in ["'", '"']: + deactivate = c + # Handle comments + elif c == "#": + comment_pos = pos + break + # Handle brackets + elif c in ('(', '[', '{'): + bracket_stack.append((pos, c)) + elif c in (')', ']', '}'): + if bracket_stack and bracket_stack[-1][1] == \ + {')': '(', ']': '[', '}': '{'}[c]: + bracket_stack.pop() + else: + bracket_unmatched_closing.append(c) + del pos, deactivate, escaped + # If no closing brackets are left over from this line, + # check the ones from previous iterations' prevlines + if not bracket_unmatched_closing: + for c in list(closing_brackets): + if bracket_stack and bracket_stack[-1][1] == \ + {')': '(', ']': '[', '}': '{'}[c]: + bracket_stack.pop() + closing_brackets.remove(c) + else: + break + del c + closing_brackets = bracket_unmatched_closing + closing_brackets + return (bracket_stack, closing_brackets, comment_pos) + + def fix_indent(self, *args, **kwargs): + """Indent line according to the preferences""" + if self.is_python_like(): + ret = self.fix_indent_smart(*args, **kwargs) + else: + ret = self.simple_indentation(*args, **kwargs) + return ret + + def simple_indentation(self, forward=True, **kwargs): + """ + Simply preserve the indentation-level of the previous line. + """ + cursor = self.textCursor() + block_nb = cursor.blockNumber() + prev_block = self.document().findBlockByNumber(block_nb - 1) + prevline = to_text_string(prev_block.text()) + + indentation = re.match(r"\s*", prevline).group() + # Unident + if not forward: + indentation = indentation[len(self.indent_chars):] + + cursor.insertText(indentation) + return False # simple indentation don't fix indentation + + def find_indentation(self, forward=True, comment_or_string=False, + cur_indent=None): + """ + Find indentation (Python only, no text selection) + + forward=True: fix indent only if text is not enough indented + (otherwise force indent) + forward=False: fix indent only if text is too much indented + (otherwise force unindent) + + comment_or_string: Do not adjust indent level for + unmatched opening brackets and keywords + + max_blank_lines: maximum number of blank lines to search before giving + up + + cur_indent: current indent. This is the indent before we started + processing. E.g. when returning, indent before rstrip. + + Returns the indentation for the current line + + Assumes self.is_python_like() to return True + """ + cursor = self.textCursor() + block_nb = cursor.blockNumber() + # find the line that contains our scope + line_in_block = False + visual_indent = False + add_indent = 0 # How many levels of indent to add + prevline = None + prevtext = "" + empty_lines = True + + closing_brackets = [] + for prevline in range(block_nb - 1, -1, -1): + cursor.movePosition(QTextCursor.PreviousBlock) + prevtext = to_text_string(cursor.block().text()).rstrip() + + bracket_stack, closing_brackets, comment_pos = self.__get_brackets( + prevtext, closing_brackets) + + if not prevtext: + continue + + if prevtext.endswith((':', '\\')): + # Presume a block was started + line_in_block = True # add one level of indent to correct_indent + # Does this variable actually do *anything* of relevance? + # comment_or_string = True + + if bracket_stack or not closing_brackets: + break + + if prevtext.strip() != '': + empty_lines = False + + if empty_lines and prevline is not None and prevline < block_nb - 2: + # The previous line is too far, ignore + prevtext = '' + prevline = block_nb - 2 + line_in_block = False + + # splits of prevtext happen a few times. Let's just do it once + words = re.split(r'[\s\(\[\{\}\]\)]', prevtext.lstrip()) + + if line_in_block: + add_indent += 1 + + if prevtext and not comment_or_string: + if bracket_stack: + # Hanging indent + if prevtext.endswith(('(', '[', '{')): + add_indent += 1 + if words[0] in ('class', 'def', 'elif', 'except', 'for', + 'if', 'while', 'with'): + add_indent += 1 + elif not ( # I'm not sure this block should exist here + ( + self.tab_stop_width_spaces + if self.indent_chars == '\t' else + len(self.indent_chars) + ) * 2 < len(prevtext)): + visual_indent = True + else: + # There's stuff after unmatched opening brackets + visual_indent = True + elif (words[-1] in ('continue', 'break', 'pass',) + or words[0] == "return" and not line_in_block + ): + add_indent -= 1 + + if prevline: + prevline_indent = self.get_block_indentation(prevline) + else: + prevline_indent = 0 + + if visual_indent: # can only be true if bracket_stack + correct_indent = bracket_stack[-1][0] + 1 + elif add_indent: + # Indent + if self.indent_chars == '\t': + correct_indent = prevline_indent + self.tab_stop_width_spaces * add_indent + else: + correct_indent = prevline_indent + len(self.indent_chars) * add_indent + else: + correct_indent = prevline_indent + + # TODO untangle this block + if prevline and not bracket_stack and not prevtext.endswith(':'): + if forward: + # Keep indentation of previous line + ref_line = block_nb - 1 + else: + # Find indentation context + ref_line = prevline + if cur_indent is None: + cur_indent = self.get_block_indentation(ref_line) + is_blank = not self.get_text_line(ref_line).strip() + trailing_text = self.get_text_line(block_nb).strip() + # If brackets are matched and no block gets opened + # Match the above line's indent and nudge to the next multiple of 4 + + if cur_indent < prevline_indent and (trailing_text or is_blank): + # if line directly above is blank or there is text after cursor + # Ceiling division + correct_indent = -(-cur_indent // len(self.indent_chars)) * \ + len(self.indent_chars) + return correct_indent + + def fix_indent_smart(self, forward=True, comment_or_string=False, + cur_indent=None): + """ + Fix indentation (Python only, no text selection) + + forward=True: fix indent only if text is not enough indented + (otherwise force indent) + forward=False: fix indent only if text is too much indented + (otherwise force unindent) + + comment_or_string: Do not adjust indent level for + unmatched opening brackets and keywords + + max_blank_lines: maximum number of blank lines to search before giving + up + + cur_indent: current indent. This is the indent before we started + processing. E.g. when returning, indent before rstrip. + + Returns True if indent needed to be fixed + + Assumes self.is_python_like() to return True + """ + cursor = self.textCursor() + block_nb = cursor.blockNumber() + indent = self.get_block_indentation(block_nb) + + correct_indent = self.find_indentation( + forward, comment_or_string, cur_indent) + + if correct_indent >= 0 and not ( + indent == correct_indent or + forward and indent > correct_indent or + not forward and indent < correct_indent + ): + # Insert the determined indent + cursor = self.textCursor() + cursor.movePosition(QTextCursor.StartOfBlock) + if self.indent_chars == '\t': + indent = indent // self.tab_stop_width_spaces + cursor.setPosition(cursor.position()+indent, QTextCursor.KeepAnchor) + cursor.removeSelectedText() + if self.indent_chars == '\t': + indent_text = ( + '\t' * (correct_indent // self.tab_stop_width_spaces) + + ' ' * (correct_indent % self.tab_stop_width_spaces) + ) + else: + indent_text = ' '*correct_indent + cursor.insertText(indent_text) + return True + return False + + @Slot() + def clear_all_output(self): + """Removes all output in the ipynb format (Json only)""" + try: + nb = nbformat.reads(self.toPlainText(), as_version=4) + if nb.cells: + for cell in nb.cells: + if 'outputs' in cell: + cell['outputs'] = [] + if 'prompt_number' in cell: + cell['prompt_number'] = None + # We do the following rather than using self.setPlainText + # to benefit from QTextEdit's undo/redo feature. + self.selectAll() + self.skip_rstrip = True + self.insertPlainText(nbformat.writes(nb)) + self.skip_rstrip = False + except Exception as e: + QMessageBox.critical(self, _('Removal error'), + _("It was not possible to remove outputs from " + "this notebook. The error is:\n\n") + \ + to_text_string(e)) + return + + @Slot() + def convert_notebook(self): + """Convert an IPython notebook to a Python script in editor""" + try: + nb = nbformat.reads(self.toPlainText(), as_version=4) + script = nbexporter().from_notebook_node(nb)[0] + except Exception as e: + QMessageBox.critical(self, _('Conversion error'), + _("It was not possible to convert this " + "notebook. The error is:\n\n") + \ + to_text_string(e)) + return + self.sig_new_file.emit(script) + + def indent(self, force=False): + """ + Indent current line or selection + + force=True: indent even if cursor is not a the beginning of the line + """ + leading_text = self.get_text('sol', 'cursor') + if self.has_selected_text(): + self.add_prefix(self.indent_chars) + elif (force or not leading_text.strip() or + (self.tab_indents and self.tab_mode)): + if self.is_python_like(): + if not self.fix_indent(forward=True): + self.add_prefix(self.indent_chars) + else: + self.add_prefix(self.indent_chars) + else: + if len(self.indent_chars) > 1: + length = len(self.indent_chars) + self.insert_text(" "*(length-(len(leading_text) % length))) + else: + self.insert_text(self.indent_chars) + + def indent_or_replace(self): + """Indent or replace by 4 spaces depending on selection and tab mode""" + if (self.tab_indents and self.tab_mode) or not self.has_selected_text(): + self.indent() + else: + cursor = self.textCursor() + if (self.get_selected_text() == + to_text_string(cursor.block().text())): + self.indent() + else: + cursor1 = self.textCursor() + cursor1.setPosition(cursor.selectionStart()) + cursor2 = self.textCursor() + cursor2.setPosition(cursor.selectionEnd()) + if cursor1.blockNumber() != cursor2.blockNumber(): + self.indent() + else: + self.replace(self.indent_chars) + + def unindent(self, force=False): + """ + Unindent current line or selection + + force=True: unindent even if cursor is not a the beginning of the line + """ + if self.has_selected_text(): + if self.indent_chars == "\t": + # Tabs, remove one tab + self.remove_prefix(self.indent_chars) + else: + # Spaces + space_count = len(self.indent_chars) + leading_spaces = self.__spaces_for_prefix() + remainder = leading_spaces % space_count + if remainder: + # Get block on "space multiple grid". + # See spyder-ide/spyder#5734. + self.remove_prefix(" "*remainder) + else: + # Unindent one space multiple + self.remove_prefix(self.indent_chars) + else: + leading_text = self.get_text('sol', 'cursor') + if (force or not leading_text.strip() or + (self.tab_indents and self.tab_mode)): + if self.is_python_like(): + if not self.fix_indent(forward=False): + self.remove_prefix(self.indent_chars) + elif leading_text.endswith('\t'): + self.remove_prefix('\t') + else: + self.remove_prefix(self.indent_chars) + + @Slot() + def toggle_comment(self): + """Toggle comment on current line or selection""" + cursor = self.textCursor() + start_pos, end_pos = sorted([cursor.selectionStart(), + cursor.selectionEnd()]) + cursor.setPosition(end_pos) + last_line = cursor.block().blockNumber() + if cursor.atBlockStart() and start_pos != end_pos: + last_line -= 1 + cursor.setPosition(start_pos) + first_line = cursor.block().blockNumber() + # If the selection contains only commented lines and surrounding + # whitespace, uncomment. Otherwise, comment. + is_comment_or_whitespace = True + at_least_one_comment = False + for _line_nb in range(first_line, last_line+1): + text = to_text_string(cursor.block().text()).lstrip() + is_comment = text.startswith(self.comment_string) + is_whitespace = (text == '') + is_comment_or_whitespace *= (is_comment or is_whitespace) + if is_comment: + at_least_one_comment = True + cursor.movePosition(QTextCursor.NextBlock) + if is_comment_or_whitespace and at_least_one_comment: + self.uncomment() + else: + self.comment() + + def is_comment(self, block): + """Detect inline comments. + + Return True if the block is an inline comment. + """ + if block is None: + return False + text = to_text_string(block.text()).lstrip() + return text.startswith(self.comment_string) + + def comment(self): + """Comment current line or selection.""" + self.add_prefix(self.comment_string + ' ') + + def uncomment(self): + """Uncomment current line or selection.""" + blockcomment = self.unblockcomment() + if not blockcomment: + self.remove_prefix(self.comment_string) + + def __blockcomment_bar(self, compatibility=False): + """Handle versions of blockcomment bar for backwards compatibility.""" + # Blockcomment bar in Spyder version >= 4 + blockcomment_bar = self.comment_string + ' ' + '=' * ( + 79 - len(self.comment_string + ' ')) + if compatibility: + # Blockcomment bar in Spyder version < 4 + blockcomment_bar = self.comment_string + '=' * ( + 79 - len(self.comment_string)) + return blockcomment_bar + + def transform_to_uppercase(self): + """Change to uppercase current line or selection.""" + cursor = self.textCursor() + prev_pos = cursor.position() + selected_text = to_text_string(cursor.selectedText()) + + if len(selected_text) == 0: + prev_pos = cursor.position() + cursor.select(QTextCursor.WordUnderCursor) + selected_text = to_text_string(cursor.selectedText()) + + s = selected_text.upper() + cursor.insertText(s) + self.set_cursor_position(prev_pos) + + def transform_to_lowercase(self): + """Change to lowercase current line or selection.""" + cursor = self.textCursor() + prev_pos = cursor.position() + selected_text = to_text_string(cursor.selectedText()) + + if len(selected_text) == 0: + prev_pos = cursor.position() + cursor.select(QTextCursor.WordUnderCursor) + selected_text = to_text_string(cursor.selectedText()) + + s = selected_text.lower() + cursor.insertText(s) + self.set_cursor_position(prev_pos) + + def blockcomment(self): + """Block comment current line or selection.""" + comline = self.__blockcomment_bar() + self.get_line_separator() + cursor = self.textCursor() + if self.has_selected_text(): + self.extend_selection_to_complete_lines() + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + else: + start_pos = end_pos = cursor.position() + cursor.beginEditBlock() + cursor.setPosition(start_pos) + cursor.movePosition(QTextCursor.StartOfBlock) + while cursor.position() <= end_pos: + cursor.insertText(self.comment_string + " ") + cursor.movePosition(QTextCursor.EndOfBlock) + if cursor.atEnd(): + break + cursor.movePosition(QTextCursor.NextBlock) + end_pos += len(self.comment_string + " ") + cursor.setPosition(end_pos) + cursor.movePosition(QTextCursor.EndOfBlock) + if cursor.atEnd(): + cursor.insertText(self.get_line_separator()) + else: + cursor.movePosition(QTextCursor.NextBlock) + cursor.insertText(comline) + cursor.setPosition(start_pos) + cursor.movePosition(QTextCursor.StartOfBlock) + cursor.insertText(comline) + cursor.endEditBlock() + + def unblockcomment(self): + """Un-block comment current line or selection.""" + # Needed for backward compatibility with Spyder previous blockcomments. + # See spyder-ide/spyder#2845. + unblockcomment = self.__unblockcomment() + if not unblockcomment: + unblockcomment = self.__unblockcomment(compatibility=True) + else: + return unblockcomment + + def __unblockcomment(self, compatibility=False): + """Un-block comment current line or selection helper.""" + def __is_comment_bar(cursor): + return to_text_string(cursor.block().text() + ).startswith( + self.__blockcomment_bar(compatibility=compatibility)) + # Finding first comment bar + cursor1 = self.textCursor() + if __is_comment_bar(cursor1): + return + while not __is_comment_bar(cursor1): + cursor1.movePosition(QTextCursor.PreviousBlock) + if cursor1.blockNumber() == 0: + break + if not __is_comment_bar(cursor1): + return False + + def __in_block_comment(cursor): + cs = self.comment_string + return to_text_string(cursor.block().text()).startswith(cs) + # Finding second comment bar + cursor2 = QTextCursor(cursor1) + cursor2.movePosition(QTextCursor.NextBlock) + while not __is_comment_bar(cursor2) and __in_block_comment(cursor2): + cursor2.movePosition(QTextCursor.NextBlock) + if cursor2.block() == self.document().lastBlock(): + break + if not __is_comment_bar(cursor2): + return False + # Removing block comment + cursor3 = self.textCursor() + cursor3.beginEditBlock() + cursor3.setPosition(cursor1.position()) + cursor3.movePosition(QTextCursor.NextBlock) + while cursor3.position() < cursor2.position(): + cursor3.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor) + if not cursor3.atBlockEnd(): + # standard commenting inserts '# ' but a trailing space on an + # empty line might be stripped. + if not compatibility: + cursor3.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor) + cursor3.removeSelectedText() + cursor3.movePosition(QTextCursor.NextBlock) + for cursor in (cursor2, cursor1): + cursor3.setPosition(cursor.position()) + cursor3.select(QTextCursor.BlockUnderCursor) + cursor3.removeSelectedText() + cursor3.endEditBlock() + return True + + def create_new_cell(self): + firstline = '# %%' + self.get_line_separator() + endline = self.get_line_separator() + cursor = self.textCursor() + if self.has_selected_text(): + self.extend_selection_to_complete_lines() + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + endline = self.get_line_separator() + '# %%' + else: + start_pos = end_pos = cursor.position() + + # Add cell comment or enclose current selection in cells + cursor.beginEditBlock() + cursor.setPosition(end_pos) + cursor.movePosition(QTextCursor.EndOfBlock) + cursor.insertText(endline) + cursor.setPosition(start_pos) + cursor.movePosition(QTextCursor.StartOfBlock) + cursor.insertText(firstline) + cursor.endEditBlock() + + # ---- Kill ring handlers + # Taken from Jupyter's QtConsole + # Copyright (c) 2001-2015, IPython Development Team + # Copyright (c) 2015-, Jupyter Development Team + # ------------------------------------------------------------------------- + def kill_line_end(self): + """Kill the text on the current line from the cursor forward""" + cursor = self.textCursor() + cursor.clearSelection() + cursor.movePosition(QTextCursor.EndOfLine, QTextCursor.KeepAnchor) + if not cursor.hasSelection(): + # Line deletion + cursor.movePosition(QTextCursor.NextBlock, + QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + def kill_line_start(self): + """Kill the text on the current line from the cursor backward""" + cursor = self.textCursor() + cursor.clearSelection() + cursor.movePosition(QTextCursor.StartOfBlock, + QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + def _get_word_start_cursor(self, position): + """Find the start of the word to the left of the given position. If a + sequence of non-word characters precedes the first word, skip over + them. (This emulates the behavior of bash, emacs, etc.) + """ + document = self.document() + position -= 1 + while (position and not + self.is_letter_or_number(document.characterAt(position))): + position -= 1 + while position and self.is_letter_or_number( + document.characterAt(position)): + position -= 1 + cursor = self.textCursor() + cursor.setPosition(self.next_cursor_position()) + return cursor + + def _get_word_end_cursor(self, position): + """Find the end of the word to the right of the given position. If a + sequence of non-word characters precedes the first word, skip over + them. (This emulates the behavior of bash, emacs, etc.) + """ + document = self.document() + cursor = self.textCursor() + position = cursor.position() + cursor.movePosition(QTextCursor.End) + end = cursor.position() + while (position < end and + not self.is_letter_or_number(document.characterAt(position))): + position = self.next_cursor_position(position) + while (position < end and + self.is_letter_or_number(document.characterAt(position))): + position = self.next_cursor_position(position) + cursor.setPosition(position) + return cursor + + def kill_prev_word(self): + """Kill the previous word""" + position = self.textCursor().position() + cursor = self._get_word_start_cursor(position) + cursor.setPosition(position, QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + def kill_next_word(self): + """Kill the next word""" + position = self.textCursor().position() + cursor = self._get_word_end_cursor(position) + cursor.setPosition(position, QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + # ---- Autoinsertion of quotes/colons + # ------------------------------------------------------------------------- + def __get_current_color(self, cursor=None): + """Get the syntax highlighting color for the current cursor position""" + if cursor is None: + cursor = self.textCursor() + + block = cursor.block() + pos = cursor.position() - block.position() # relative pos within block + layout = block.layout() + block_formats = layout.formats() + + if block_formats: + # To easily grab current format for autoinsert_colons + if cursor.atBlockEnd(): + current_format = block_formats[-1].format + else: + current_format = None + for fmt in block_formats: + if (pos >= fmt.start) and (pos < fmt.start + fmt.length): + current_format = fmt.format + if current_format is None: + return None + color = current_format.foreground().color().name() + return color + else: + return None + + def in_comment_or_string(self, cursor=None, position=None): + """Is the cursor or position inside or next to a comment or string? + + If *cursor* is None, *position* is used instead. If *position* is also + None, then the current cursor position is used. + """ + if self.highlighter: + if cursor is None: + cursor = self.textCursor() + if position: + cursor.setPosition(position) + current_color = self.__get_current_color(cursor=cursor) + + comment_color = self.highlighter.get_color_name('comment') + string_color = self.highlighter.get_color_name('string') + if (current_color == comment_color) or (current_color == string_color): + return True + else: + return False + else: + return False + + def __colon_keyword(self, text): + stmt_kws = ['def', 'for', 'if', 'while', 'with', 'class', 'elif', + 'except'] + whole_kws = ['else', 'try', 'except', 'finally'] + text = text.lstrip() + words = text.split() + if any([text == wk for wk in whole_kws]): + return True + elif len(words) < 2: + return False + elif any([words[0] == sk for sk in stmt_kws]): + return True + else: + return False + + def __forbidden_colon_end_char(self, text): + end_chars = [':', '\\', '[', '{', '(', ','] + text = text.rstrip() + if any([text.endswith(c) for c in end_chars]): + return True + else: + return False + + def __has_colon_not_in_brackets(self, text): + """ + Return whether a string has a colon which is not between brackets. + This function returns True if the given string has a colon which is + not between a pair of (round, square or curly) brackets. It assumes + that the brackets in the string are balanced. + """ + bracket_ext = self.editor_extensions.get(CloseBracketsExtension) + for pos, char in enumerate(text): + if (char == ':' and + not bracket_ext.unmatched_brackets_in_line(text[:pos])): + return True + return False + + def __has_unmatched_opening_bracket(self): + """ + Checks if there are any unmatched opening brackets before the current + cursor position. + """ + position = self.textCursor().position() + for brace in [']', ')', '}']: + match = self.find_brace_match(position, brace, forward=False) + if match is not None: + return True + return False + + def autoinsert_colons(self): + """Decide if we want to autoinsert colons""" + bracket_ext = self.editor_extensions.get(CloseBracketsExtension) + self.completion_widget.hide() + line_text = self.get_text('sol', 'cursor') + if not self.textCursor().atBlockEnd(): + return False + elif self.in_comment_or_string(): + return False + elif not self.__colon_keyword(line_text): + return False + elif self.__forbidden_colon_end_char(line_text): + return False + elif bracket_ext.unmatched_brackets_in_line(line_text): + return False + elif self.__has_colon_not_in_brackets(line_text): + return False + elif self.__has_unmatched_opening_bracket(): + return False + else: + return True + + def next_char(self): + cursor = self.textCursor() + cursor.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor) + next_char = to_text_string(cursor.selectedText()) + return next_char + + def in_comment(self, cursor=None, position=None): + """Returns True if the given position is inside a comment. + + Parameters + ---------- + cursor : QTextCursor, optional + The position to check. + position : int, optional + The position to check if *cursor* is None. This parameter + is ignored when *cursor* is not None. + + If both *cursor* and *position* are none, then the position returned + by self.textCursor() is used instead. + """ + if self.highlighter: + if cursor is None: + cursor = self.textCursor() + if position is not None: + cursor.setPosition(position) + current_color = self.__get_current_color(cursor) + comment_color = self.highlighter.get_color_name('comment') + return (current_color == comment_color) + else: + return False + + def in_string(self, cursor=None, position=None): + """Returns True if the given position is inside a string. + + Parameters + ---------- + cursor : QTextCursor, optional + The position to check. + position : int, optional + The position to check if *cursor* is None. This parameter + is ignored when *cursor* is not None. + + If both *cursor* and *position* are none, then the position returned + by self.textCursor() is used instead. + """ + if self.highlighter: + if cursor is None: + cursor = self.textCursor() + if position is not None: + cursor.setPosition(position) + current_color = self.__get_current_color(cursor) + string_color = self.highlighter.get_color_name('string') + return (current_color == string_color) + else: + return False + + # ---- Qt Event handlers + # ------------------------------------------------------------------------- + def setup_context_menu(self): + """Setup context menu""" + self.undo_action = create_action( + self, _("Undo"), icon=ima.icon('undo'), + shortcut=self.get_shortcut('undo'), triggered=self.undo) + self.redo_action = create_action( + self, _("Redo"), icon=ima.icon('redo'), + shortcut=self.get_shortcut('redo'), triggered=self.redo) + self.cut_action = create_action( + self, _("Cut"), icon=ima.icon('editcut'), + shortcut=self.get_shortcut('cut'), triggered=self.cut) + self.copy_action = create_action( + self, _("Copy"), icon=ima.icon('editcopy'), + shortcut=self.get_shortcut('copy'), triggered=self.copy) + self.paste_action = create_action( + self, _("Paste"), icon=ima.icon('editpaste'), + shortcut=self.get_shortcut('paste'), + triggered=self.paste) + selectall_action = create_action( + self, _("Select All"), icon=ima.icon('selectall'), + shortcut=self.get_shortcut('select all'), + triggered=self.selectAll) + toggle_comment_action = create_action( + self, _("Comment")+"/"+_("Uncomment"), icon=ima.icon('comment'), + shortcut=self.get_shortcut('toggle comment'), + triggered=self.toggle_comment) + self.clear_all_output_action = create_action( + self, _("Clear all ouput"), icon=ima.icon('ipython_console'), + triggered=self.clear_all_output) + self.ipynb_convert_action = create_action( + self, _("Convert to Python file"), icon=ima.icon('python'), + triggered=self.convert_notebook) + self.gotodef_action = create_action( + self, _("Go to definition"), + shortcut=self.get_shortcut('go to definition'), + triggered=self.go_to_definition_from_cursor) + + self.inspect_current_object_action = create_action( + self, _("Inspect current object"), + icon=ima.icon('MessageBoxInformation'), + shortcut=self.get_shortcut('inspect current object'), + triggered=self.sig_show_object_info) + + # Run actions + + # Zoom actions + zoom_in_action = create_action( + self, _("Zoom in"), icon=ima.icon('zoom_in'), + shortcut=QKeySequence(QKeySequence.ZoomIn), + triggered=self.zoom_in) + zoom_out_action = create_action( + self, _("Zoom out"), icon=ima.icon('zoom_out'), + shortcut=QKeySequence(QKeySequence.ZoomOut), + triggered=self.zoom_out) + zoom_reset_action = create_action( + self, _("Zoom reset"), shortcut=QKeySequence("Ctrl+0"), + triggered=self.zoom_reset) + + # Docstring + writer = self.writer_docstring + self.docstring_action = create_action( + self, _("Generate docstring"), + shortcut=self.get_shortcut('docstring'), + triggered=writer.write_docstring_at_first_line_of_function) + + # Document formatting + formatter = self.get_conf( + ('provider_configuration', 'lsp', 'values', 'formatting'), + default='', + section='completions', + ) + self.format_action = create_action( + self, + _('Format file or selection with {0}').format( + formatter.capitalize()), + shortcut=self.get_shortcut('autoformatting'), + triggered=self.format_document_or_range) + + self.format_action.setEnabled(False) + + # Build menu + # TODO: Change to SpyderMenu when the editor is migrated to the new + # API + self.menu = QMenu(self) + actions_1 = [self.gotodef_action, self.inspect_current_object_action, + None, self.undo_action, self.redo_action, None, + self.cut_action, self.copy_action, + self.paste_action, selectall_action] + actions_2 = [None, zoom_in_action, zoom_out_action, zoom_reset_action, + None, toggle_comment_action, self.docstring_action, + self.format_action] + if nbformat is not None: + nb_actions = [self.clear_all_output_action, + self.ipynb_convert_action, None] + actions = actions_1 + nb_actions + actions_2 + add_actions(self.menu, actions) + else: + actions = actions_1 + actions_2 + add_actions(self.menu, actions) + + # Read-only context-menu + # TODO: Change to SpyderMenu when the editor is migrated to the new + # API + self.readonly_menu = QMenu(self) + add_actions(self.readonly_menu, + (self.copy_action, None, selectall_action, + self.gotodef_action)) + + def keyReleaseEvent(self, event): + """Override Qt method.""" + self.sig_key_released.emit(event) + key = event.key() + direction_keys = {Qt.Key_Up, Qt.Key_Left, Qt.Key_Right, Qt.Key_Down} + if key in direction_keys: + self.request_cursor_event() + + # Update decorations after releasing these keys because they don't + # trigger the emission of the valueChanged signal in + # verticalScrollBar. + # See https://bugreports.qt.io/browse/QTBUG-25365 + if key in {Qt.Key_Up, Qt.Key_Down}: + self.update_decorations_timer.start() + + # This necessary to run our Pygments highlighter again after the + # user generated text changes + if event.text(): + # Stop the active timer and start it again to not run it on + # every event + if self.timer_syntax_highlight.isActive(): + self.timer_syntax_highlight.stop() + + # Adjust interval to rehighlight according to the lines + # present in the file + total_lines = self.get_line_count() + if total_lines < 1000: + self.timer_syntax_highlight.setInterval(600) + elif total_lines < 2000: + self.timer_syntax_highlight.setInterval(800) + else: + self.timer_syntax_highlight.setInterval(1000) + self.timer_syntax_highlight.start() + + self._restore_editor_cursor_and_selections() + super(CodeEditor, self).keyReleaseEvent(event) + event.ignore() + + def event(self, event): + """Qt method override.""" + if event.type() == QEvent.ShortcutOverride: + event.ignore() + return False + else: + return super(CodeEditor, self).event(event) + + def _handle_keypress_event(self, event): + """Handle keypress events.""" + TextEditBaseWidget.keyPressEvent(self, event) + + # Trigger the following actions only if the event generates + # a text change. + text = to_text_string(event.text()) + if text: + # The next three lines are a workaround for a quirk of + # QTextEdit on Linux with Qt < 5.15, MacOs and Windows. + # See spyder-ide/spyder#12663 and + # https://bugreports.qt.io/browse/QTBUG-35861 + if ( + parse(QT_VERSION) < parse('5.15') + or os.name == 'nt' or sys.platform == 'darwin' + ): + cursor = self.textCursor() + cursor.setPosition(cursor.position()) + self.setTextCursor(cursor) + self.sig_text_was_inserted.emit() + + def keyPressEvent(self, event): + """Reimplement Qt method.""" + if self.completions_hint_after_ms > 0: + self._completions_hint_idle = False + self._timer_completions_hint.start(self.completions_hint_after_ms) + else: + self._set_completions_hint_idle() + + # Send the signal to the editor's extension. + event.ignore() + self.sig_key_pressed.emit(event) + + self._last_pressed_key = key = event.key() + self._last_key_pressed_text = text = to_text_string(event.text()) + has_selection = self.has_selected_text() + ctrl = event.modifiers() & Qt.ControlModifier + shift = event.modifiers() & Qt.ShiftModifier + + if text: + self.clear_occurrences() + + + if key in {Qt.Key_Up, Qt.Key_Left, Qt.Key_Right, Qt.Key_Down}: + self.hide_tooltip() + + if event.isAccepted(): + # The event was handled by one of the editor extension. + return + + if key in [Qt.Key_Control, Qt.Key_Shift, Qt.Key_Alt, + Qt.Key_Meta, Qt.KeypadModifier]: + # The user pressed only a modifier key. + if ctrl: + pos = self.mapFromGlobal(QCursor.pos()) + pos = self.calculate_real_position_from_global(pos) + if self._handle_goto_uri_event(pos): + event.accept() + return + + if self._handle_goto_definition_event(pos): + event.accept() + return + return + + # ---- Handle hard coded and builtin actions + operators = {'+', '-', '*', '**', '/', '//', '%', '@', '<<', '>>', + '&', '|', '^', '~', '<', '>', '<=', '>=', '==', '!='} + delimiters = {',', ':', ';', '@', '=', '->', '+=', '-=', '*=', '/=', + '//=', '%=', '@=', '&=', '|=', '^=', '>>=', '<<=', '**='} + + if text not in self.auto_completion_characters: + if text in operators or text in delimiters: + 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() + ): + self.textCursor().beginEditBlock() + self.insert_text(':' + self.get_line_separator()) + if self.strip_trailing_spaces_on_modify: + self.fix_and_strip_indent() + else: + self.fix_indent() + self.textCursor().endEditBlock() + elif self.is_completion_widget_visible(): + self.select_completion_list() + else: + self.textCursor().beginEditBlock() + cur_indent = self.get_block_indentation( + self.textCursor().blockNumber()) + self._handle_keypress_event(event) + # Check if we're in a comment or a string at the + # current position + cmt_or_str_cursor = self.in_comment_or_string() + + # Check if the line start with a comment or string + cursor = self.textCursor() + cursor.setPosition(cursor.block().position(), + QTextCursor.KeepAnchor) + cmt_or_str_line_begin = self.in_comment_or_string( + cursor=cursor) + + # Check if we are in a comment or a string + cmt_or_str = cmt_or_str_cursor and cmt_or_str_line_begin + + if self.strip_trailing_spaces_on_modify: + self.fix_and_strip_indent( + comment_or_string=cmt_or_str, + cur_indent=cur_indent) + else: + self.fix_indent(comment_or_string=cmt_or_str, + cur_indent=cur_indent) + self.textCursor().endEditBlock() + elif key == Qt.Key_Insert and not shift and not ctrl: + self.setOverwriteMode(not self.overwriteMode()) + elif key == Qt.Key_Backspace and not shift and not ctrl: + if has_selection or not self.intelligent_backspace: + self._handle_keypress_event(event) + else: + leading_text = self.get_text('sol', 'cursor') + leading_length = len(leading_text) + 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 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) + ): + cursor = self.textCursor() + cursor.movePosition(QTextCursor.PreviousCharacter) + cursor.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor, 2) + cursor.removeSelectedText() + else: + self._handle_keypress_event(event) + elif key == Qt.Key_Home: + self.stdkey_home(shift, ctrl) + elif key == Qt.Key_End: + # See spyder-ide/spyder#495: on MacOS X, it is necessary to + # 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 + ): + 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()) + ): + # 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() + ): + self.insert_text(text) + self.request_signature() + 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()) + prevtxt = (to_text_string(self.textCursor().block(). + previous().text())) + if self.language == 'Python': + prevtxt = prevtxt.rstrip() + 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 + ): + self.completion_widget.hide() + leading_text = self.get_text('sol', 'cursor') + if leading_text.lstrip() in ('elif', 'except'): + ind = lambda txt: len(txt)-len(txt.lstrip()) + prevtxt = (to_text_string(self.textCursor().block(). + previous().text())) + if self.language == 'Python': + prevtxt = prevtxt.rstrip() + if ind(leading_text) == ind(prevtxt): + self.unindent(force=True) + self._handle_keypress_event(event) + elif key == Qt.Key_Tab and not ctrl: + # Important note:
'
+ '{} ({} {})'
+ )
+
+ msglist = []
+ max_lines_msglist = 25
+ sorted_code_analysis = sorted(code_analysis, key=lambda i: i[2])
+ for src, code, sev, msg in sorted_code_analysis:
+ if src == 'pylint' and '[' in msg and ']' in msg:
+ # Remove extra redundant info from pylint messages
+ msg = msg.split(']')[-1]
+
+ msg = msg.strip()
+ # Avoid messing TODO, FIXME
+ # Prevent error if msg only has one element
+ if len(msg) > 1:
+ msg = msg[0].upper() + msg[1:]
+
+ # Get individual lines following paragraph format and handle
+ # symbols like '<' and '>' to not mess with br tags
+ msg = msg.replace('<', '<').replace('>', '>')
+ paragraphs = msg.splitlines()
+ new_paragraphs = []
+ long_paragraphs = 0
+ lines_per_message = 6
+ for paragraph in paragraphs:
+ new_paragraph = textwrap.wrap(
+ paragraph,
+ width=self._DEFAULT_MAX_HINT_WIDTH)
+ if lines_per_message > 2:
+ if len(new_paragraph) > 1:
+ new_paragraph = ''.join(new_paragraph[:2]) + '...' + long_paragraphs += 1 + lines_per_message -= 2 + else: + new_paragraph = '
'.join(new_paragraph) + lines_per_message -= 1 + new_paragraphs.append(new_paragraph) + + if len(new_paragraphs) > 1: + # Define max lines taking into account that in the same + # tooltip you can find multiple warnings and messages + # and each one can have multiple lines + if long_paragraphs != 0: + max_lines = 3 + max_lines_msglist -= max_lines * 2 + else: + max_lines = 5 + max_lines_msglist -= max_lines + msg = '
'.join(new_paragraphs[:max_lines]) + '
' + else: + msg = '
'.join(new_paragraphs) + + base_64 = ima.base64_from_icon(icons[sev], size, size) + if max_lines_msglist >= 0: + msglist.append(template.format(base_64, msg, src, + code, size=size)) + + if msglist: + self.show_tooltip( + title=_("Code analysis"), + text='\n'.join(msglist), + title_color=QStylePalette.COLOR_ACCENT_4, + at_line=line_number, + with_html_format=True + ) + self.highlight_line_warning(block_data) + + def highlight_line_warning(self, block_data): + """Highlight errors and warnings in this editor.""" + self.clear_extra_selections('code_analysis_highlight') + self.highlight_selection('code_analysis_highlight', + block_data._selection(), + background_color=block_data.color) + self.linenumberarea.update() + + def get_current_warnings(self): + """ + Get all warnings for the current editor and return + a list with the message and line number. + """ + block = self.document().firstBlock() + line_count = self.document().blockCount() + warnings = [] + while True: + data = block.userData() + if data and data.code_analysis: + for warning in data.code_analysis: + warnings.append([warning[-1], block.blockNumber() + 1]) + # See spyder-ide/spyder#9924 + if block.blockNumber() + 1 == line_count: + break + block = block.next() + return warnings + + def go_to_next_warning(self): + """ + Go to next code warning message and return new cursor position. + """ + block = self.textCursor().block() + line_count = self.document().blockCount() + for __ in range(line_count): + line_number = block.blockNumber() + 1 + if line_number < line_count: + block = block.next() + else: + block = self.document().firstBlock() + + data = block.userData() + if data and data.code_analysis: + line_number = block.blockNumber() + 1 + self.go_to_line(line_number) + self.show_code_analysis_results(line_number, data) + return self.get_position('cursor') + + def go_to_previous_warning(self): + """ + Go to previous code warning message and return new cursor position. + """ + block = self.textCursor().block() + line_count = self.document().blockCount() + for __ in range(line_count): + line_number = block.blockNumber() + 1 + if line_number > 1: + block = block.previous() + else: + block = self.document().lastBlock() + + data = block.userData() + if data and data.code_analysis: + line_number = block.blockNumber() + 1 + self.go_to_line(line_number) + self.show_code_analysis_results(line_number, data) + return self.get_position('cursor') + + def cell_list(self): + """Get the outline explorer data for all cells.""" + for oedata in self.outlineexplorer_data_list(): + if oedata.def_type == OED.CELL: + yield oedata + + def get_cell_code(self, cell): + """ + Get cell code for a given cell. + + If the cell doesn't exist, raises an exception + """ + selected_block = None + if is_string(cell): + for oedata in self.cell_list(): + if oedata.def_name == cell: + selected_block = oedata.block + break + else: + if cell == 0: + selected_block = self.document().firstBlock() + else: + cell_list = list(self.cell_list()) + if cell <= len(cell_list): + selected_block = cell_list[cell - 1].block + + if not selected_block: + raise RuntimeError("Cell {} not found.".format(repr(cell))) + + cursor = QTextCursor(selected_block) + text, _, off_pos, col_pos = self.get_cell_as_executable_code(cursor) + return text + + def get_cell_code_and_position(self, cell): + """ + Get code and position for a given cell. + + If the cell doesn't exist, raise an exception. + """ + selected_block = None + if is_string(cell): + for oedata in self.cell_list(): + if oedata.def_name == cell: + selected_block = oedata.block + break + else: + if cell == 0: + selected_block = self.document().firstBlock() + else: + cell_list = list(self.cell_list()) + if cell <= len(cell_list): + selected_block = cell_list[cell - 1].block + + if not selected_block: + raise RuntimeError("Cell {} not found.".format(repr(cell))) + + cursor = QTextCursor(selected_block) + text, _, off_pos, col_pos = self.get_cell_as_executable_code(cursor) + return text, off_pos, col_pos + + def get_cell_count(self): + """Get number of cells in document.""" + return 1 + len(list(self.cell_list())) + + # ---- Tasks management + # ------------------------------------------------------------------------- + def go_to_next_todo(self): + """Go to next todo and return new cursor position""" + block = self.textCursor().block() + line_count = self.document().blockCount() + while True: + if block.blockNumber()+1 < line_count: + block = block.next() + else: + block = self.document().firstBlock() + data = block.userData() + if data and data.todo: + break + line_number = block.blockNumber()+1 + self.go_to_line(line_number) + self.show_tooltip( + title=_("To do"), + text=data.todo, + title_color=QStylePalette.COLOR_ACCENT_4, + at_line=line_number, + ) + + return self.get_position('cursor') + + def process_todo(self, todo_results): + """Process todo finder results""" + for data in self.blockuserdata_list(): + data.todo = '' + + for message, line_number in todo_results: + block = self.document().findBlockByNumber(line_number - 1) + data = block.userData() + if not data: + data = BlockUserData(self) + data.todo = message + block.setUserData(data) + self.sig_flags_changed.emit() + + # ---- Comments/Indentation + # ------------------------------------------------------------------------- + def add_prefix(self, prefix): + """Add prefix to current line or selected line(s)""" + cursor = self.textCursor() + if self.has_selected_text(): + # Add prefix to selected line(s) + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + + # Let's see if selection begins at a block start + first_pos = min([start_pos, end_pos]) + first_cursor = self.textCursor() + first_cursor.setPosition(first_pos) + + cursor.beginEditBlock() + cursor.setPosition(end_pos) + # Check if end_pos is at the start of a block: if so, starting + # changes from the previous block + if cursor.atBlockStart(): + cursor.movePosition(QTextCursor.PreviousBlock) + if cursor.position() < start_pos: + cursor.setPosition(start_pos) + move_number = self.__spaces_for_prefix() + + while cursor.position() >= start_pos: + cursor.movePosition(QTextCursor.StartOfBlock) + line_text = to_text_string(cursor.block().text()) + if (self.get_character(cursor.position()) == ' ' + and '#' in prefix and not line_text.isspace() + or (not line_text.startswith(' ') + and line_text != '')): + cursor.movePosition(QTextCursor.Right, + QTextCursor.MoveAnchor, + move_number) + cursor.insertText(prefix) + elif '#' not in prefix: + cursor.insertText(prefix) + if cursor.blockNumber() == 0: + # Avoid infinite loop when indenting the very first line + break + cursor.movePosition(QTextCursor.PreviousBlock) + cursor.movePosition(QTextCursor.EndOfBlock) + cursor.endEditBlock() + else: + # Add prefix to current line + cursor.beginEditBlock() + cursor.movePosition(QTextCursor.StartOfBlock) + if self.get_character(cursor.position()) == ' ' and '#' in prefix: + cursor.movePosition(QTextCursor.NextWord) + cursor.insertText(prefix) + cursor.endEditBlock() + + def __spaces_for_prefix(self): + """Find the less indented level of text.""" + cursor = self.textCursor() + if self.has_selected_text(): + # Add prefix to selected line(s) + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + + # Let's see if selection begins at a block start + first_pos = min([start_pos, end_pos]) + first_cursor = self.textCursor() + first_cursor.setPosition(first_pos) + + cursor.beginEditBlock() + cursor.setPosition(end_pos) + # Check if end_pos is at the start of a block: if so, starting + # changes from the previous block + if cursor.atBlockStart(): + cursor.movePosition(QTextCursor.PreviousBlock) + if cursor.position() < start_pos: + cursor.setPosition(start_pos) + + number_spaces = -1 + while cursor.position() >= start_pos: + cursor.movePosition(QTextCursor.StartOfBlock) + line_text = to_text_string(cursor.block().text()) + start_with_space = line_text.startswith(' ') + left_number_spaces = self.__number_of_spaces(line_text) + if not start_with_space: + left_number_spaces = 0 + if ((number_spaces == -1 + or number_spaces > left_number_spaces) + and not line_text.isspace() and line_text != ''): + number_spaces = left_number_spaces + if cursor.blockNumber() == 0: + # Avoid infinite loop when indenting the very first line + break + cursor.movePosition(QTextCursor.PreviousBlock) + cursor.movePosition(QTextCursor.EndOfBlock) + cursor.endEditBlock() + return number_spaces + + def remove_suffix(self, suffix): + """ + Remove suffix from current line (there should not be any selection) + """ + cursor = self.textCursor() + cursor.setPosition(cursor.position() - qstring_length(suffix), + QTextCursor.KeepAnchor) + if to_text_string(cursor.selectedText()) == suffix: + cursor.removeSelectedText() + + def remove_prefix(self, prefix): + """Remove prefix from current line or selected line(s)""" + cursor = self.textCursor() + if self.has_selected_text(): + # Remove prefix from selected line(s) + start_pos, end_pos = sorted([cursor.selectionStart(), + cursor.selectionEnd()]) + cursor.setPosition(start_pos) + if not cursor.atBlockStart(): + cursor.movePosition(QTextCursor.StartOfBlock) + start_pos = cursor.position() + cursor.beginEditBlock() + cursor.setPosition(end_pos) + # Check if end_pos is at the start of a block: if so, starting + # changes from the previous block + if cursor.atBlockStart(): + cursor.movePosition(QTextCursor.PreviousBlock) + if cursor.position() < start_pos: + cursor.setPosition(start_pos) + + cursor.movePosition(QTextCursor.StartOfBlock) + old_pos = None + while cursor.position() >= start_pos: + new_pos = cursor.position() + if old_pos == new_pos: + break + else: + old_pos = new_pos + line_text = to_text_string(cursor.block().text()) + self.__remove_prefix(prefix, cursor, line_text) + cursor.movePosition(QTextCursor.PreviousBlock) + cursor.endEditBlock() + else: + # Remove prefix from current line + cursor.movePosition(QTextCursor.StartOfBlock) + line_text = to_text_string(cursor.block().text()) + self.__remove_prefix(prefix, cursor, line_text) + + def __remove_prefix(self, prefix, cursor, line_text): + """Handle the removal of the prefix for a single line.""" + cursor.movePosition(QTextCursor.Right, + QTextCursor.MoveAnchor, + line_text.find(prefix)) + # Handle prefix remove for comments with spaces + if (prefix.strip() and line_text.lstrip().startswith(prefix + ' ') + or line_text.startswith(prefix + ' ') and '#' in prefix): + cursor.movePosition(QTextCursor.Right, + QTextCursor.KeepAnchor, len(prefix + ' ')) + # Check for prefix without space + elif (prefix.strip() and line_text.lstrip().startswith(prefix) + or line_text.startswith(prefix)): + cursor.movePosition(QTextCursor.Right, + QTextCursor.KeepAnchor, len(prefix)) + cursor.removeSelectedText() + + def __even_number_of_spaces(self, line_text, group=0): + """ + Get if there is a correct indentation from a group of spaces of a line. + """ + spaces = re.findall(r'\s+', line_text) + if len(spaces) - 1 >= group: + return len(spaces[group]) % len(self.indent_chars) == 0 + + def __number_of_spaces(self, line_text, group=0): + """Get the number of spaces from a group of spaces in a line.""" + spaces = re.findall(r'\s+', line_text) + if len(spaces) - 1 >= group: + return len(spaces[group]) + + + def fix_indent(self, *args, **kwargs): + """Indent line according to the preferences""" + if self.is_python_like(): + ret = self.fix_indent_smart(*args, **kwargs) + else: + ret = self.simple_indentation(*args, **kwargs) + return ret + + def simple_indentation(self, forward=True, **kwargs): + """ + Simply preserve the indentation-level of the previous line. + """ + cursor = self.textCursor() + block_nb = cursor.blockNumber() + prev_block = self.document().findBlockByNumber(block_nb - 1) + prevline = to_text_string(prev_block.text()) + + indentation = re.match(r"\s*", prevline).group() + # Unident + if not forward: + indentation = indentation[len(self.indent_chars):] + + cursor.insertText(indentation) + return False # simple indentation don't fix indentation + + def find_indentation(self, forward=True, comment_or_string=False, + cur_indent=None): + """ + Find indentation (Python only, no text selection) + + forward=True: fix indent only if text is not enough indented + (otherwise force indent) + forward=False: fix indent only if text is too much indented + (otherwise force unindent) + + comment_or_string: Do not adjust indent level for + unmatched opening brackets and keywords + + max_blank_lines: maximum number of blank lines to search before giving + up + + cur_indent: current indent. This is the indent before we started + processing. E.g. when returning, indent before rstrip. + + Returns the indentation for the current line + + Assumes self.is_python_like() to return True + """ + cursor = self.textCursor() + block_nb = cursor.blockNumber() + # find the line that contains our scope + line_in_block = False + visual_indent = False + add_indent = 0 # How many levels of indent to add + prevline = None + prevtext = "" + empty_lines = True + + closing_brackets = [] + for prevline in range(block_nb - 1, -1, -1): + cursor.movePosition(QTextCursor.PreviousBlock) + prevtext = to_text_string(cursor.block().text()).rstrip() + + bracket_stack, closing_brackets, comment_pos = self.__get_brackets( + prevtext, closing_brackets) + + if not prevtext: + continue + + if prevtext.endswith((':', '\\')): + # Presume a block was started + line_in_block = True # add one level of indent to correct_indent + # Does this variable actually do *anything* of relevance? + # comment_or_string = True + + if bracket_stack or not closing_brackets: + break + + if prevtext.strip() != '': + empty_lines = False + + if empty_lines and prevline is not None and prevline < block_nb - 2: + # The previous line is too far, ignore + prevtext = '' + prevline = block_nb - 2 + line_in_block = False + + # splits of prevtext happen a few times. Let's just do it once + words = re.split(r'[\s\(\[\{\}\]\)]', prevtext.lstrip()) + + if line_in_block: + add_indent += 1 + + if prevtext and not comment_or_string: + if bracket_stack: + # Hanging indent + if prevtext.endswith(('(', '[', '{')): + add_indent += 1 + if words[0] in ('class', 'def', 'elif', 'except', 'for', + 'if', 'while', 'with'): + add_indent += 1 + elif not ( # I'm not sure this block should exist here + ( + self.tab_stop_width_spaces + if self.indent_chars == '\t' else + len(self.indent_chars) + ) * 2 < len(prevtext)): + visual_indent = True + else: + # There's stuff after unmatched opening brackets + visual_indent = True + elif (words[-1] in ('continue', 'break', 'pass',) + or words[0] == "return" and not line_in_block + ): + add_indent -= 1 + + if prevline: + prevline_indent = self.get_block_indentation(prevline) + else: + prevline_indent = 0 + + if visual_indent: # can only be true if bracket_stack + correct_indent = bracket_stack[-1][0] + 1 + elif add_indent: + # Indent + if self.indent_chars == '\t': + correct_indent = prevline_indent + self.tab_stop_width_spaces * add_indent + else: + correct_indent = prevline_indent + len(self.indent_chars) * add_indent + else: + correct_indent = prevline_indent + + # TODO untangle this block + if prevline and not bracket_stack and not prevtext.endswith(':'): + if forward: + # Keep indentation of previous line + ref_line = block_nb - 1 + else: + # Find indentation context + ref_line = prevline + if cur_indent is None: + cur_indent = self.get_block_indentation(ref_line) + is_blank = not self.get_text_line(ref_line).strip() + trailing_text = self.get_text_line(block_nb).strip() + # If brackets are matched and no block gets opened + # Match the above line's indent and nudge to the next multiple of 4 + + if cur_indent < prevline_indent and (trailing_text or is_blank): + # if line directly above is blank or there is text after cursor + # Ceiling division + correct_indent = -(-cur_indent // len(self.indent_chars)) * \ + len(self.indent_chars) + return correct_indent + + def fix_indent_smart(self, forward=True, comment_or_string=False, + cur_indent=None): + """ + Fix indentation (Python only, no text selection) + + forward=True: fix indent only if text is not enough indented + (otherwise force indent) + forward=False: fix indent only if text is too much indented + (otherwise force unindent) + + comment_or_string: Do not adjust indent level for + unmatched opening brackets and keywords + + max_blank_lines: maximum number of blank lines to search before giving + up + + cur_indent: current indent. This is the indent before we started + processing. E.g. when returning, indent before rstrip. + + Returns True if indent needed to be fixed + + Assumes self.is_python_like() to return True + """ + cursor = self.textCursor() + block_nb = cursor.blockNumber() + indent = self.get_block_indentation(block_nb) + + correct_indent = self.find_indentation( + forward, comment_or_string, cur_indent) + + if correct_indent >= 0 and not ( + indent == correct_indent or + forward and indent > correct_indent or + not forward and indent < correct_indent + ): + # Insert the determined indent + cursor = self.textCursor() + cursor.movePosition(QTextCursor.StartOfBlock) + if self.indent_chars == '\t': + indent = indent // self.tab_stop_width_spaces + cursor.setPosition(cursor.position()+indent, QTextCursor.KeepAnchor) + cursor.removeSelectedText() + if self.indent_chars == '\t': + indent_text = ( + '\t' * (correct_indent // self.tab_stop_width_spaces) + + ' ' * (correct_indent % self.tab_stop_width_spaces) + ) + else: + indent_text = ' '*correct_indent + cursor.insertText(indent_text) + return True + return False + + @Slot() + def clear_all_output(self): + """Removes all output in the ipynb format (Json only)""" + try: + nb = nbformat.reads(self.toPlainText(), as_version=4) + if nb.cells: + for cell in nb.cells: + if 'outputs' in cell: + cell['outputs'] = [] + if 'prompt_number' in cell: + cell['prompt_number'] = None + # We do the following rather than using self.setPlainText + # to benefit from QTextEdit's undo/redo feature. + self.selectAll() + self.skip_rstrip = True + self.insertPlainText(nbformat.writes(nb)) + self.skip_rstrip = False + except Exception as e: + QMessageBox.critical(self, _('Removal error'), + _("It was not possible to remove outputs from " + "this notebook. The error is:\n\n") + \ + to_text_string(e)) + return + + @Slot() + def convert_notebook(self): + """Convert an IPython notebook to a Python script in editor""" + try: + nb = nbformat.reads(self.toPlainText(), as_version=4) + script = nbexporter().from_notebook_node(nb)[0] + except Exception as e: + QMessageBox.critical(self, _('Conversion error'), + _("It was not possible to convert this " + "notebook. The error is:\n\n") + \ + to_text_string(e)) + return + self.sig_new_file.emit(script) + + def indent(self, force=False): + """ + Indent current line or selection + + force=True: indent even if cursor is not a the beginning of the line + """ + leading_text = self.get_text('sol', 'cursor') + if self.has_selected_text(): + self.add_prefix(self.indent_chars) + elif (force or not leading_text.strip() or + (self.tab_indents and self.tab_mode)): + if self.is_python_like(): + if not self.fix_indent(forward=True): + self.add_prefix(self.indent_chars) + else: + self.add_prefix(self.indent_chars) + else: + if len(self.indent_chars) > 1: + length = len(self.indent_chars) + self.insert_text(" "*(length-(len(leading_text) % length))) + else: + self.insert_text(self.indent_chars) + + def indent_or_replace(self): + """Indent or replace by 4 spaces depending on selection and tab mode""" + if (self.tab_indents and self.tab_mode) or not self.has_selected_text(): + self.indent() + else: + cursor = self.textCursor() + if (self.get_selected_text() == + to_text_string(cursor.block().text())): + self.indent() + else: + cursor1 = self.textCursor() + cursor1.setPosition(cursor.selectionStart()) + cursor2 = self.textCursor() + cursor2.setPosition(cursor.selectionEnd()) + if cursor1.blockNumber() != cursor2.blockNumber(): + self.indent() + else: + self.replace(self.indent_chars) + + def unindent(self, force=False): + """ + Unindent current line or selection + + force=True: unindent even if cursor is not a the beginning of the line + """ + if self.has_selected_text(): + if self.indent_chars == "\t": + # Tabs, remove one tab + self.remove_prefix(self.indent_chars) + else: + # Spaces + space_count = len(self.indent_chars) + leading_spaces = self.__spaces_for_prefix() + remainder = leading_spaces % space_count + if remainder: + # Get block on "space multiple grid". + # See spyder-ide/spyder#5734. + self.remove_prefix(" "*remainder) + else: + # Unindent one space multiple + self.remove_prefix(self.indent_chars) + else: + leading_text = self.get_text('sol', 'cursor') + if (force or not leading_text.strip() or + (self.tab_indents and self.tab_mode)): + if self.is_python_like(): + if not self.fix_indent(forward=False): + self.remove_prefix(self.indent_chars) + elif leading_text.endswith('\t'): + self.remove_prefix('\t') + else: + self.remove_prefix(self.indent_chars) + + @Slot() + def toggle_comment(self): + """Toggle comment on current line or selection""" + cursor = self.textCursor() + start_pos, end_pos = sorted([cursor.selectionStart(), + cursor.selectionEnd()]) + cursor.setPosition(end_pos) + last_line = cursor.block().blockNumber() + if cursor.atBlockStart() and start_pos != end_pos: + last_line -= 1 + cursor.setPosition(start_pos) + first_line = cursor.block().blockNumber() + # If the selection contains only commented lines and surrounding + # whitespace, uncomment. Otherwise, comment. + is_comment_or_whitespace = True + at_least_one_comment = False + for _line_nb in range(first_line, last_line+1): + text = to_text_string(cursor.block().text()).lstrip() + is_comment = text.startswith(self.comment_string) + is_whitespace = (text == '') + is_comment_or_whitespace *= (is_comment or is_whitespace) + if is_comment: + at_least_one_comment = True + cursor.movePosition(QTextCursor.NextBlock) + if is_comment_or_whitespace and at_least_one_comment: + self.uncomment() + else: + self.comment() + + def is_comment(self, block): + """Detect inline comments. + + Return True if the block is an inline comment. + """ + if block is None: + return False + text = to_text_string(block.text()).lstrip() + return text.startswith(self.comment_string) + + def comment(self): + """Comment current line or selection.""" + self.add_prefix(self.comment_string + ' ') + + def uncomment(self): + """Uncomment current line or selection.""" + blockcomment = self.unblockcomment() + if not blockcomment: + self.remove_prefix(self.comment_string) + + def __blockcomment_bar(self, compatibility=False): + """Handle versions of blockcomment bar for backwards compatibility.""" + # Blockcomment bar in Spyder version >= 4 + blockcomment_bar = self.comment_string + ' ' + '=' * ( + 79 - len(self.comment_string + ' ')) + if compatibility: + # Blockcomment bar in Spyder version < 4 + blockcomment_bar = self.comment_string + '=' * ( + 79 - len(self.comment_string)) + return blockcomment_bar + + def transform_to_uppercase(self): + """Change to uppercase current line or selection.""" + cursor = self.textCursor() + prev_pos = cursor.position() + selected_text = to_text_string(cursor.selectedText()) + + if len(selected_text) == 0: + prev_pos = cursor.position() + cursor.select(QTextCursor.WordUnderCursor) + selected_text = to_text_string(cursor.selectedText()) + + s = selected_text.upper() + cursor.insertText(s) + self.set_cursor_position(prev_pos) + + def transform_to_lowercase(self): + """Change to lowercase current line or selection.""" + cursor = self.textCursor() + prev_pos = cursor.position() + selected_text = to_text_string(cursor.selectedText()) + + if len(selected_text) == 0: + prev_pos = cursor.position() + cursor.select(QTextCursor.WordUnderCursor) + selected_text = to_text_string(cursor.selectedText()) + + s = selected_text.lower() + cursor.insertText(s) + self.set_cursor_position(prev_pos) + + def blockcomment(self): + """Block comment current line or selection.""" + comline = self.__blockcomment_bar() + self.get_line_separator() + cursor = self.textCursor() + if self.has_selected_text(): + self.extend_selection_to_complete_lines() + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + else: + start_pos = end_pos = cursor.position() + cursor.beginEditBlock() + cursor.setPosition(start_pos) + cursor.movePosition(QTextCursor.StartOfBlock) + while cursor.position() <= end_pos: + cursor.insertText(self.comment_string + " ") + cursor.movePosition(QTextCursor.EndOfBlock) + if cursor.atEnd(): + break + cursor.movePosition(QTextCursor.NextBlock) + end_pos += len(self.comment_string + " ") + cursor.setPosition(end_pos) + cursor.movePosition(QTextCursor.EndOfBlock) + if cursor.atEnd(): + cursor.insertText(self.get_line_separator()) + else: + cursor.movePosition(QTextCursor.NextBlock) + cursor.insertText(comline) + cursor.setPosition(start_pos) + cursor.movePosition(QTextCursor.StartOfBlock) + cursor.insertText(comline) + cursor.endEditBlock() + + def unblockcomment(self): + """Un-block comment current line or selection.""" + # Needed for backward compatibility with Spyder previous blockcomments. + # See spyder-ide/spyder#2845. + unblockcomment = self.__unblockcomment() + if not unblockcomment: + unblockcomment = self.__unblockcomment(compatibility=True) + else: + return unblockcomment + + def __unblockcomment(self, compatibility=False): + """Un-block comment current line or selection helper.""" + def __is_comment_bar(cursor): + return to_text_string(cursor.block().text() + ).startswith( + self.__blockcomment_bar(compatibility=compatibility)) + # Finding first comment bar + cursor1 = self.textCursor() + if __is_comment_bar(cursor1): + return + while not __is_comment_bar(cursor1): + cursor1.movePosition(QTextCursor.PreviousBlock) + if cursor1.blockNumber() == 0: + break + if not __is_comment_bar(cursor1): + return False + + def __in_block_comment(cursor): + cs = self.comment_string + return to_text_string(cursor.block().text()).startswith(cs) + # Finding second comment bar + cursor2 = QTextCursor(cursor1) + cursor2.movePosition(QTextCursor.NextBlock) + while not __is_comment_bar(cursor2) and __in_block_comment(cursor2): + cursor2.movePosition(QTextCursor.NextBlock) + if cursor2.block() == self.document().lastBlock(): + break + if not __is_comment_bar(cursor2): + return False + # Removing block comment + cursor3 = self.textCursor() + cursor3.beginEditBlock() + cursor3.setPosition(cursor1.position()) + cursor3.movePosition(QTextCursor.NextBlock) + while cursor3.position() < cursor2.position(): + cursor3.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor) + if not cursor3.atBlockEnd(): + # standard commenting inserts '# ' but a trailing space on an + # empty line might be stripped. + if not compatibility: + cursor3.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor) + cursor3.removeSelectedText() + cursor3.movePosition(QTextCursor.NextBlock) + for cursor in (cursor2, cursor1): + cursor3.setPosition(cursor.position()) + cursor3.select(QTextCursor.BlockUnderCursor) + cursor3.removeSelectedText() + cursor3.endEditBlock() + return True + + def create_new_cell(self): + firstline = '# %%' + self.get_line_separator() + endline = self.get_line_separator() + cursor = self.textCursor() + if self.has_selected_text(): + self.extend_selection_to_complete_lines() + start_pos, end_pos = cursor.selectionStart(), cursor.selectionEnd() + endline = self.get_line_separator() + '# %%' + else: + start_pos = end_pos = cursor.position() + + # Add cell comment or enclose current selection in cells + cursor.beginEditBlock() + cursor.setPosition(end_pos) + cursor.movePosition(QTextCursor.EndOfBlock) + cursor.insertText(endline) + cursor.setPosition(start_pos) + cursor.movePosition(QTextCursor.StartOfBlock) + cursor.insertText(firstline) + cursor.endEditBlock() + + # ---- Kill ring handlers + # Taken from Jupyter's QtConsole + # Copyright (c) 2001-2015, IPython Development Team + # Copyright (c) 2015-, Jupyter Development Team + # ------------------------------------------------------------------------- + def kill_line_end(self): + """Kill the text on the current line from the cursor forward""" + cursor = self.textCursor() + cursor.clearSelection() + cursor.movePosition(QTextCursor.EndOfLine, QTextCursor.KeepAnchor) + if not cursor.hasSelection(): + # Line deletion + cursor.movePosition(QTextCursor.NextBlock, + QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + def kill_line_start(self): + """Kill the text on the current line from the cursor backward""" + cursor = self.textCursor() + cursor.clearSelection() + cursor.movePosition(QTextCursor.StartOfBlock, + QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + def _get_word_start_cursor(self, position): + """Find the start of the word to the left of the given position. If a + sequence of non-word characters precedes the first word, skip over + them. (This emulates the behavior of bash, emacs, etc.) + """ + document = self.document() + position -= 1 + while (position and not + self.is_letter_or_number(document.characterAt(position))): + position -= 1 + while position and self.is_letter_or_number( + document.characterAt(position)): + position -= 1 + cursor = self.textCursor() + cursor.setPosition(self.next_cursor_position()) + return cursor + + def _get_word_end_cursor(self, position): + """Find the end of the word to the right of the given position. If a + sequence of non-word characters precedes the first word, skip over + them. (This emulates the behavior of bash, emacs, etc.) + """ + document = self.document() + cursor = self.textCursor() + position = cursor.position() + cursor.movePosition(QTextCursor.End) + end = cursor.position() + while (position < end and + not self.is_letter_or_number(document.characterAt(position))): + position = self.next_cursor_position(position) + while (position < end and + self.is_letter_or_number(document.characterAt(position))): + position = self.next_cursor_position(position) + cursor.setPosition(position) + return cursor + + def kill_prev_word(self): + """Kill the previous word""" + position = self.textCursor().position() + cursor = self._get_word_start_cursor(position) + cursor.setPosition(position, QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + def kill_next_word(self): + """Kill the next word""" + position = self.textCursor().position() + cursor = self._get_word_end_cursor(position) + cursor.setPosition(position, QTextCursor.KeepAnchor) + self._kill_ring.kill_cursor(cursor) + self.setTextCursor(cursor) + + # ---- Autoinsertion of quotes/colons + # ------------------------------------------------------------------------- + def __get_current_color(self, cursor=None): + """Get the syntax highlighting color for the current cursor position""" + if cursor is None: + cursor = self.textCursor() + + block = cursor.block() + pos = cursor.position() - block.position() # relative pos within block + layout = block.layout() + block_formats = layout.formats() + + if block_formats: + # To easily grab current format for autoinsert_colons + if cursor.atBlockEnd(): + current_format = block_formats[-1].format + else: + current_format = None + for fmt in block_formats: + if (pos >= fmt.start) and (pos < fmt.start + fmt.length): + current_format = fmt.format + if current_format is None: + return None + color = current_format.foreground().color().name() + return color + else: + return None + + def in_comment_or_string(self, cursor=None, position=None): + """Is the cursor or position inside or next to a comment or string? + + If *cursor* is None, *position* is used instead. If *position* is also + None, then the current cursor position is used. + """ + if self.highlighter: + if cursor is None: + cursor = self.textCursor() + if position: + cursor.setPosition(position) + current_color = self.__get_current_color(cursor=cursor) + + comment_color = self.highlighter.get_color_name('comment') + string_color = self.highlighter.get_color_name('string') + if (current_color == comment_color) or (current_color == string_color): + return True + else: + return False + else: + return False + + def __colon_keyword(self, text): + stmt_kws = ['def', 'for', 'if', 'while', 'with', 'class', 'elif', + 'except'] + whole_kws = ['else', 'try', 'except', 'finally'] + text = text.lstrip() + words = text.split() + if any([text == wk for wk in whole_kws]): + return True + elif len(words) < 2: + return False + elif any([words[0] == sk for sk in stmt_kws]): + return True + else: + return False + + def __forbidden_colon_end_char(self, text): + end_chars = [':', '\\', '[', '{', '(', ','] + text = text.rstrip() + if any([text.endswith(c) for c in end_chars]): + return True + else: + return False + + def __has_colon_not_in_brackets(self, text): + """ + Return whether a string has a colon which is not between brackets. + This function returns True if the given string has a colon which is + not between a pair of (round, square or curly) brackets. It assumes + that the brackets in the string are balanced. + """ + bracket_ext = self.editor_extensions.get(CloseBracketsExtension) + for pos, char in enumerate(text): + if (char == ':' and + not bracket_ext.unmatched_brackets_in_line(text[:pos])): + return True + return False + + def __has_unmatched_opening_bracket(self): + """ + Checks if there are any unmatched opening brackets before the current + cursor position. + """ + position = self.textCursor().position() + for brace in [']', ')', '}']: + match = self.find_brace_match(position, brace, forward=False) + if match is not None: + return True + return False + + def autoinsert_colons(self): + """Decide if we want to autoinsert colons""" + bracket_ext = self.editor_extensions.get(CloseBracketsExtension) + self.completion_widget.hide() + line_text = self.get_text('sol', 'cursor') + if not self.textCursor().atBlockEnd(): + return False + elif self.in_comment_or_string(): + return False + elif not self.__colon_keyword(line_text): + return False + elif self.__forbidden_colon_end_char(line_text): + return False + elif bracket_ext.unmatched_brackets_in_line(line_text): + return False + elif self.__has_colon_not_in_brackets(line_text): + return False + elif self.__has_unmatched_opening_bracket(): + return False + else: + return True + + def next_char(self): + cursor = self.textCursor() + cursor.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor) + next_char = to_text_string(cursor.selectedText()) + return next_char + + def in_comment(self, cursor=None, position=None): + """Returns True if the given position is inside a comment. + + Parameters + ---------- + cursor : QTextCursor, optional + The position to check. + position : int, optional + The position to check if *cursor* is None. This parameter + is ignored when *cursor* is not None. + + If both *cursor* and *position* are none, then the position returned + by self.textCursor() is used instead. + """ + if self.highlighter: + if cursor is None: + cursor = self.textCursor() + if position is not None: + cursor.setPosition(position) + current_color = self.__get_current_color(cursor) + comment_color = self.highlighter.get_color_name('comment') + return (current_color == comment_color) + else: + return False + + def in_string(self, cursor=None, position=None): + """Returns True if the given position is inside a string. + + Parameters + ---------- + cursor : QTextCursor, optional + The position to check. + position : int, optional + The position to check if *cursor* is None. This parameter + is ignored when *cursor* is not None. + + If both *cursor* and *position* are none, then the position returned + by self.textCursor() is used instead. + """ + if self.highlighter: + if cursor is None: + cursor = self.textCursor() + if position is not None: + cursor.setPosition(position) + current_color = self.__get_current_color(cursor) + string_color = self.highlighter.get_color_name('string') + return (current_color == string_color) + else: + return False + + # ---- Qt Event handlers + # ------------------------------------------------------------------------- + def setup_context_menu(self): + """Setup context menu""" + self.undo_action = create_action( + self, _("Undo"), icon=ima.icon('undo'), + shortcut=self.get_shortcut('undo'), triggered=self.undo) + self.redo_action = create_action( + self, _("Redo"), icon=ima.icon('redo'), + shortcut=self.get_shortcut('redo'), triggered=self.redo) + self.cut_action = create_action( + self, _("Cut"), icon=ima.icon('editcut'), + shortcut=self.get_shortcut('cut'), triggered=self.cut) + self.copy_action = create_action( + self, _("Copy"), icon=ima.icon('editcopy'), + shortcut=self.get_shortcut('copy'), triggered=self.copy) + self.paste_action = create_action( + self, _("Paste"), icon=ima.icon('editpaste'), + shortcut=self.get_shortcut('paste'), + triggered=self.paste) + selectall_action = create_action( + self, _("Select All"), icon=ima.icon('selectall'), + shortcut=self.get_shortcut('select all'), + triggered=self.selectAll) + toggle_comment_action = create_action( + self, _("Comment")+"/"+_("Uncomment"), icon=ima.icon('comment'), + shortcut=self.get_shortcut('toggle comment'), + triggered=self.toggle_comment) + self.clear_all_output_action = create_action( + self, _("Clear all ouput"), icon=ima.icon('ipython_console'), + triggered=self.clear_all_output) + self.ipynb_convert_action = create_action( + self, _("Convert to Python file"), icon=ima.icon('python'), + triggered=self.convert_notebook) + self.gotodef_action = create_action( + self, _("Go to definition"), + shortcut=self.get_shortcut('go to definition'), + triggered=self.go_to_definition_from_cursor) + + self.inspect_current_object_action = create_action( + self, _("Inspect current object"), + icon=ima.icon('MessageBoxInformation'), + shortcut=self.get_shortcut('inspect current object'), + triggered=self.sig_show_object_info) + + # Run actions + + # Zoom actions + zoom_in_action = create_action( + self, _("Zoom in"), icon=ima.icon('zoom_in'), + shortcut=QKeySequence(QKeySequence.ZoomIn), + triggered=self.zoom_in) + zoom_out_action = create_action( + self, _("Zoom out"), icon=ima.icon('zoom_out'), + shortcut=QKeySequence(QKeySequence.ZoomOut), + triggered=self.zoom_out) + zoom_reset_action = create_action( + self, _("Zoom reset"), shortcut=QKeySequence("Ctrl+0"), + triggered=self.zoom_reset) + + # Docstring + writer = self.writer_docstring + self.docstring_action = create_action( + self, _("Generate docstring"), + shortcut=self.get_shortcut('docstring'), + triggered=writer.write_docstring_at_first_line_of_function) + + # Document formatting + formatter = self.get_conf( + ('provider_configuration', 'lsp', 'values', 'formatting'), + default='', + section='completions', + ) + self.format_action = create_action( + self, + _('Format file or selection with {0}').format( + formatter.capitalize()), + shortcut=self.get_shortcut('autoformatting'), + triggered=self.format_document_or_range) + + self.format_action.setEnabled(False) + + # Build menu + # TODO: Change to SpyderMenu when the editor is migrated to the new + # API + self.menu = QMenu(self) + actions_1 = [self.gotodef_action, self.inspect_current_object_action, + None, self.undo_action, self.redo_action, None, + self.cut_action, self.copy_action, + self.paste_action, selectall_action] + actions_2 = [None, zoom_in_action, zoom_out_action, zoom_reset_action, + None, toggle_comment_action, self.docstring_action, + self.format_action] + if nbformat is not None: + nb_actions = [self.clear_all_output_action, + self.ipynb_convert_action, None] + actions = actions_1 + nb_actions + actions_2 + add_actions(self.menu, actions) + else: + actions = actions_1 + actions_2 + add_actions(self.menu, actions) + + # Read-only context-menu + # TODO: Change to SpyderMenu when the editor is migrated to the new + # API + self.readonly_menu = QMenu(self) + add_actions(self.readonly_menu, + (self.copy_action, None, selectall_action, + self.gotodef_action)) + + def keyReleaseEvent(self, event): + """Override Qt method.""" + self.sig_key_released.emit(event) + key = event.key() + direction_keys = {Qt.Key_Up, Qt.Key_Left, Qt.Key_Right, Qt.Key_Down} + if key in direction_keys: + self.request_cursor_event() + + # Update decorations after releasing these keys because they don't + # trigger the emission of the valueChanged signal in + # verticalScrollBar. + # See https://bugreports.qt.io/browse/QTBUG-25365 + if key in {Qt.Key_Up, Qt.Key_Down}: + self.update_decorations_timer.start() + + # This necessary to run our Pygments highlighter again after the + # user generated text changes + if event.text(): + # Stop the active timer and start it again to not run it on + # every event + if self.timer_syntax_highlight.isActive(): + self.timer_syntax_highlight.stop() + + # Adjust interval to rehighlight according to the lines + # present in the file + total_lines = self.get_line_count() + if total_lines < 1000: + self.timer_syntax_highlight.setInterval(600) + elif total_lines < 2000: + self.timer_syntax_highlight.setInterval(800) + else: + self.timer_syntax_highlight.setInterval(1000) + self.timer_syntax_highlight.start() + + self._restore_editor_cursor_and_selections() + super(CodeEditor, self).keyReleaseEvent(event) + event.ignore() + + def event(self, event): + """Qt method override.""" + if event.type() == QEvent.ShortcutOverride: + event.ignore() + return False + else: + return super(CodeEditor, self).event(event) + + def _handle_keypress_event(self, event): + """Handle keypress events.""" + TextEditBaseWidget.keyPressEvent(self, event) + + # Trigger the following actions only if the event generates + # a text change. + text = to_text_string(event.text()) + if text: + # The next three lines are a workaround for a quirk of + # QTextEdit on Linux with Qt < 5.15, MacOs and Windows. + # See spyder-ide/spyder#12663 and + # https://bugreports.qt.io/browse/QTBUG-35861 + if ( + parse(QT_VERSION) < parse('5.15') + or os.name == 'nt' or sys.platform == 'darwin' + ): + cursor = self.textCursor() + cursor.setPosition(cursor.position()) + self.setTextCursor(cursor) + self.sig_text_was_inserted.emit() + + def keyPressEvent(self, event): + """Reimplement Qt method.""" + if self.completions_hint_after_ms > 0: + self._completions_hint_idle = False + self._timer_completions_hint.start(self.completions_hint_after_ms) + else: + self._set_completions_hint_idle() + + # Send the signal to the editor's extension. + event.ignore() + self.sig_key_pressed.emit(event) + + self._last_pressed_key = key = event.key() + self._last_key_pressed_text = text = to_text_string(event.text()) + has_selection = self.has_selected_text() + ctrl = event.modifiers() & Qt.ControlModifier + shift = event.modifiers() & Qt.ShiftModifier + + if text: + self.clear_occurrences() + + + if key in {Qt.Key_Up, Qt.Key_Left, Qt.Key_Right, Qt.Key_Down}: + self.hide_tooltip() + + if event.isAccepted(): + # The event was handled by one of the editor extension. + return + + if key in [Qt.Key_Control, Qt.Key_Shift, Qt.Key_Alt, + Qt.Key_Meta, Qt.KeypadModifier]: + # The user pressed only a modifier key. + if ctrl: + pos = self.mapFromGlobal(QCursor.pos()) + pos = self.calculate_real_position_from_global(pos) + if self._handle_goto_uri_event(pos): + event.accept() + return + + if self._handle_goto_definition_event(pos): + event.accept() + return + return + + # ---- Handle hard coded and builtin actions + operators = {'+', '-', '*', '**', '/', '//', '%', '@', '<<', '>>', + '&', '|', '^', '~', '<', '>', '<=', '>=', '==', '!='} + delimiters = {',', ':', ';', '@', '=', '->', '+=', '-=', '*=', '/=', + '//=', '%=', '@=', '&=', '|=', '^=', '>>=', '<<=', '**='} + + if text not in self.auto_completion_characters: + if text in operators or text in delimiters: + 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() + ): + self.textCursor().beginEditBlock() + self.insert_text(':' + self.get_line_separator()) + if self.strip_trailing_spaces_on_modify: + self.fix_and_strip_indent() + else: + self.fix_indent() + self.textCursor().endEditBlock() + elif self.is_completion_widget_visible(): + self.select_completion_list() + else: + self.textCursor().beginEditBlock() + cur_indent = self.get_block_indentation( + self.textCursor().blockNumber()) + self._handle_keypress_event(event) + # Check if we're in a comment or a string at the + # current position + cmt_or_str_cursor = self.in_comment_or_string() + + # Check if the line start with a comment or string + cursor = self.textCursor() + cursor.setPosition(cursor.block().position(), + QTextCursor.KeepAnchor) + cmt_or_str_line_begin = self.in_comment_or_string( + cursor=cursor) + + # Check if we are in a comment or a string + cmt_or_str = cmt_or_str_cursor and cmt_or_str_line_begin + + if self.strip_trailing_spaces_on_modify: + self.fix_and_strip_indent( + comment_or_string=cmt_or_str, + cur_indent=cur_indent) + else: + self.fix_indent(comment_or_string=cmt_or_str, + cur_indent=cur_indent) + self.textCursor().endEditBlock() + elif key == Qt.Key_Insert and not shift and not ctrl: + self.setOverwriteMode(not self.overwriteMode()) + elif key == Qt.Key_Backspace and not shift and not ctrl: + if has_selection or not self.intelligent_backspace: + self._handle_keypress_event(event) + else: + leading_text = self.get_text('sol', 'cursor') + leading_length = len(leading_text) + 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 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) + ): + cursor = self.textCursor() + cursor.movePosition(QTextCursor.PreviousCharacter) + cursor.movePosition(QTextCursor.NextCharacter, + QTextCursor.KeepAnchor, 2) + cursor.removeSelectedText() + else: + self._handle_keypress_event(event) + elif key == Qt.Key_Home: + self.stdkey_home(shift, ctrl) + elif key == Qt.Key_End: + # See spyder-ide/spyder#495: on MacOS X, it is necessary to + # 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 + ): + 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()) + ): + # 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() + ): + self.insert_text(text) + self.request_signature() + 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()) + prevtxt = (to_text_string(self.textCursor().block(). + previous().text())) + if self.language == 'Python': + prevtxt = prevtxt.rstrip() + 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 + ): + self.completion_widget.hide() + leading_text = self.get_text('sol', 'cursor') + if leading_text.lstrip() in ('elif', 'except'): + ind = lambda txt: len(txt)-len(txt.lstrip()) + prevtxt = (to_text_string(self.textCursor().block(). + previous().text())) + if self.language == 'Python': + prevtxt = prevtxt.rstrip() + if ind(leading_text) == ind(prevtxt): + self.unindent(force=True) + self._handle_keypress_event(event) + elif key == Qt.Key_Tab and not ctrl: + # Important note:
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies: