rp 0.1.1359__tar.gz → 0.1.1361__tar.gz

{rp-0.1.1359 → rp-0.1.1361}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1359
+Version: 0.1.1361
 Summary: Ryan's Python: IDE + Library + Tools
 Home-page: https://github.com/RyannDaGreat/rp
 Author: Ryan Burgert

{rp-0.1.1359 → rp-0.1.1361}/rp/prompt_toolkit/buffer.py

@@ -684,15 +684,16 @@ class Buffer(object):
 
     def save_to_undo_stack(self, clear_redo_stack=False):
         """
-        Safe current state (input text and cursor position), so that we can
+        Safe current state (input text, cursor position, selection), so that we can
         restore it by calling undo.
         """
         # Safe if the text is different from the text at the top of the stack
-        # is different. If the text is the same, just update the cursor position.
+        # is different. If the text is the same, just update the cursor position and selection.
+        selection = self.selection_state  # Use selection_state, not document.selection
         if self._undo_stack and self._undo_stack[-1][0] == self.text:
-            self._undo_stack[-1] = (self._undo_stack[-1][0], self.cursor_position)
+            self._undo_stack[-1] = (self._undo_stack[-1][0], self.cursor_position, selection)
         else:
-            self._undo_stack.append((self.text, self.cursor_position))
+            self._undo_stack.append((self.text, self.cursor_position, selection))
 
         # Saving anything to the undo stack, clears the redo stack.
         if clear_redo_stack:
@@ -1346,15 +1347,20 @@ class Buffer(object):
         # cause that the top of the undo stack is usually the same as the
         # current text, so in that case we have to pop twice.)
         while self._undo_stack:
-            text, pos = self._undo_stack.pop()
+            item = self._undo_stack.pop()
+            # Handle both old (text, pos) and new (text, pos, selection) formats
+            text, pos = item[0], item[1]
+            selection = item[2] if len(item) > 2 else None
 
             if text != self.text:
                 # Push current text to redo stack.
                 # ring_terminal_bell()
-                self._redo_stack.append((self.text, self.cursor_position))
+                self._redo_stack.append((self.text, self.cursor_position, self.selection_state))
                 # print(self._redo_stack)
-                # Set new text/cursor_position.
+                # Set new text/cursor_position, then restore selection_state
+                # (document setter triggers _text_changed which clears selection_state)
                 self.document = Document(text, cursor_position=pos)
+                self.selection_state = selection
                 break
 
     def redo(self):
@@ -1365,8 +1371,14 @@ class Buffer(object):
             self.save_to_undo_stack(clear_redo_stack=False)
 
             # Pop state from redo stack.
-            text, pos = self._redo_stack.pop()
+            item = self._redo_stack.pop()
+            # Handle both old (text, pos) and new (text, pos, selection) formats
+            text, pos = item[0], item[1]
+            selection = item[2] if len(item) > 2 else None
+            # Set text/cursor first, then restore selection_state
+            # (document setter triggers _text_changed which clears selection_state)
             self.document = Document(text, cursor_position=pos)
+            self.selection_state = selection
         # else:
         #     text_to_speech("FAILED")
 

rp-0.1.1361/rp/rp_ptpython/ast_selection.py

@@ -0,0 +1,85 @@
+"""
+AST-based smart selection for Python code.
+
+Fallback for when tree-sitter is not available. Only works with valid syntax.
+"""
+from typing import List, Tuple, Optional, Set
+import ast
+
+from .selection_utils import (
+    get_word_spans,
+    get_string_content_spans,
+    get_bracket_spans,
+    get_line_spans,
+    get_indent_paragraph_spans,
+    get_comment_block_spans,
+    find_next_span,
+    contract,
+)
+
+
+def get_ast_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get spans from Python AST nodes."""
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return set()
+
+    spans = set()
+    lines = code.split('\n')
+
+    def offset(lineno: int, col: int) -> int:
+        return sum(len(line) + 1 for line in lines[:lineno - 1]) + col
+
+    def visit(node):
+        if hasattr(node, 'lineno') and hasattr(node, 'col_offset'):
+            start = offset(node.lineno, node.col_offset)
+            if hasattr(node, 'end_lineno') and hasattr(node, 'end_col_offset'):
+                end = offset(node.end_lineno, node.end_col_offset)
+            else:
+                end = start + 1
+            spans.add((start, end))
+        for child in ast.iter_child_nodes(node):
+            visit(child)
+
+    visit(tree)
+    return spans
+
+
+def get_synthetic_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get all synthetic (non-AST) spans."""
+    spans = set()
+    spans |= get_word_spans(code)
+    spans |= get_string_content_spans(code)
+    spans |= get_bracket_spans(code)
+    spans |= get_line_spans(code)
+    spans |= get_indent_paragraph_spans(code)
+    spans |= get_comment_block_spans(code)
+    return spans
+
+
+def expand_selection(
+    code: str,
+    start: int,
+    end: int,
+    history: List[Tuple[int, int]]
+) -> Optional[Tuple[int, int, List[Tuple[int, int]]]]:
+    """Expand selection to next span."""
+    ast_spans = get_ast_spans(code)
+    synthetic = get_synthetic_spans(code)
+    all_spans = ast_spans | synthetic
+    # For AST fallback, use all AST spans as atomic (stricter validation)
+    result = find_next_span(start, end, all_spans, ast_spans, code=code)
+    if result:
+        return (result[0], result[1], history + [(start, end)])
+    return None
+
+
+def contract_selection(
+    code: str,
+    start: int,
+    end: int,
+    history: List[Tuple[int, int]]
+) -> Optional[Tuple[int, int, List[Tuple[int, int]]]]:
+    """Contract selection by popping history."""
+    return contract(history)