rp 0.1.1346__tar.gz → 0.1.1347__tar.gz

{rp-0.1.1346 → rp-0.1.1347}/PKG-INFO

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

{rp-0.1.1346 → rp-0.1.1347}/rp/list_of_modules.py

@@ -1,13 +1,4 @@
 rp.libs
-rp.libs.jedi
-rp.libs.jedi.api
-rp.libs.jedi.common
-rp.libs.jedi.evaluate
-rp.libs.jedi.evaluate.compiled
-rp.libs.jedi.evaluate.compiled.subprocess
-rp.libs.jedi.evaluate.context
-rp.libs.jedi.evaluate.gradual
-rp.libs.jedi.plugins
 rp.libs.parso
 rp.libs.parso.pgen2
 rp.libs.parso.python

{rp-0.1.1346 → rp-0.1.1347}/rp/prompt_toolkit/buffer.py

@@ -41,12 +41,183 @@ __all__ = (
     'EditReadOnlyBuffer',
     'AcceptAction',
     'Buffer',
+    'FoldManager',
     'indent',
     'unindent',
     'reshape_text',
 )
 
 
+class Fold(object):
+    """
+    Represents a fold region in the buffer.
+
+    :param start_line: Starting line number (inclusive, 0-indexed)
+    :param end_line: Ending line number (inclusive, 0-indexed)
+    :param is_open: Whether the fold is currently open or closed
+    """
+    def __init__(self, start_line, end_line, is_open=False):
+        assert start_line < end_line, "Fold must span at least 2 lines"
+        self.start_line = start_line
+        self.end_line = end_line
+        self.is_open = is_open
+
+    def contains_line(self, line):
+        """Check if this fold contains the given line number."""
+        return self.start_line < line <= self.end_line
+
+    def __repr__(self):
+        state = 'open' if self.is_open else 'closed'
+        return 'Fold(lines %d-%d, %s)' % (self.start_line, self.end_line, state)
+
+
+class FoldManager(object):
+    """
+    Manages fold regions for a buffer.
+    Handles creating, opening, closing folds and mapping between logical and visual lines.
+    """
+    def __init__(self):
+        self.folds = []  # List of Fold objects
+
+    def add_fold(self, start_line, end_line, is_open=False):
+        """Create a new fold region."""
+        fold = Fold(start_line, end_line, is_open)
+        self.folds.append(fold)
+        self._sort_folds()
+
+    def _sort_folds(self):
+        """Sort folds by start line."""
+        self.folds.sort(key=lambda f: f.start_line)
+
+    def remove_fold_at_line(self, line):
+        """Remove fold containing the given line."""
+        for fold in self.folds:
+            if fold.start_line == line or fold.contains_line(line):
+                self.folds.remove(fold)
+                return True
+        return False
+
+    def toggle_fold_at_line(self, line):
+        """Toggle fold state at the given line."""
+        fold = self.get_fold_at_line(line)
+        if fold:
+            fold.is_open = not fold.is_open
+            return True
+        return False
+
+    def open_fold_at_line(self, line):
+        """Open fold at the given line."""
+        fold = self.get_fold_at_line(line)
+        if fold:
+            fold.is_open = True
+            return True
+        return False
+
+    def close_fold_at_line(self, line):
+        """Close fold at the given line."""
+        fold = self.get_fold_at_line(line)
+        if fold:
+            fold.is_open = False
+            return True
+        return False
+
+    def get_fold_at_line(self, line):
+        """Get the fold containing the given line (including start line)."""
+        for fold in self.folds:
+            if fold.start_line == line or fold.contains_line(line):
+                return fold
+        return None
+
+    def get_folds_containing_line(self, line):
+        """Get all folds that contain the given line (for nesting)."""
+        containing_folds = []
+        for fold in self.folds:
+            if fold.contains_line(line) or fold.start_line == line:
+                containing_folds.append(fold)
+        return containing_folds
+
+    def get_fold_depth_at_line(self, line):
+        """
+        Get the nesting depth of folds at the given line.
+        Returns the number of open folds that contain this line.
+        """
+        depth = 0
+        for fold in self.folds:
+            # Count open folds that contain this line (but not the fold start line itself)
+            if fold.is_open and fold.contains_line(line):
+                depth += 1
+        return depth
+
+    def is_fold_start_line(self, line):
+        """Check if this line is the start of any fold."""
+        for fold in self.folds:
+            if fold.start_line == line:
+                return fold
+        return None
+
+    def is_line_visible(self, line):
+        """Check if a line should be visible (not folded)."""
+        for fold in self.folds:
+            if not fold.is_open and fold.contains_line(line):
+                return False
+        return True
+
+    def get_visible_lines(self, total_lines):
+        """
+        Get list of visible line numbers given total line count.
+        Returns a list of line numbers that should be displayed.
+        """
+        return [i for i in range(total_lines) if self.is_line_visible(i)]
+
+    def logical_to_visual(self, logical_line, total_lines):
+        """
+        Convert a logical line number (in the full text) to a visual line number (in the display).
+        Returns None if the line is hidden in a fold.
+        """
+        if not self.is_line_visible(logical_line):
+            return None
+
+        visual = 0
+        for i in range(logical_line):
+            if self.is_line_visible(i):
+                visual += 1
+        return visual
+
+    def visual_to_logical(self, visual_line, total_lines):
+        """
+        Convert a visual line number (in the display) to a logical line number (in the full text).
+        """
+        visible_count = 0
+        for i in range(total_lines):
+            if self.is_line_visible(i):
+                if visible_count == visual_line:
+                    return i
+                visible_count += 1
+        return total_lines - 1  # Return last line if we go past the end
+
+    def adjust_folds_for_edit(self, start_line, lines_added):
+        """
+        Adjust fold positions after text is inserted or deleted.
+
+        :param start_line: Line where edit occurred
+        :param lines_added: Number of lines added (negative if lines were deleted)
+        """
+        for fold in self.folds[:]:  # Iterate over copy
+            if fold.start_line >= start_line:
+                fold.start_line += lines_added
+                fold.end_line += lines_added
+            elif fold.end_line >= start_line:
+                fold.end_line += lines_added
+
+            # Remove folds that became invalid
+            if fold.start_line >= fold.end_line or fold.start_line < 0:
+                self.folds.remove(fold)
+
+    def clear(self):
+        """Remove all folds."""
+        self.folds = []
+
+
 class EditReadOnlyBuffer(Exception):
     " Attempt editing of read-only :class:`.Buffer`. "
 
@@ -286,6 +457,9 @@ class Buffer(object):
         # Document cache. (Avoid creating new Document instances.)
         self._document_cache = FastDictCache(Document, size=10)
 
+        # Fold manager for vim-style folding
+        self.fold_manager = FoldManager()
+
         self.reset(initial_document=initial_document)
 
     def reset(self, initial_document=None, append_to_history=False):
@@ -595,6 +769,15 @@ class Buffer(object):
         self.cursor_position += self.document.get_cursor_up_position(
             count=count, preferred_column=original_column)
 
+        # Skip folded lines - keep moving up until we hit a visible line
+        while not self.fold_manager.is_line_visible(self.document.cursor_position_row):
+            if self.document.cursor_position_row <= 0:
+                break
+            offset = self.document.get_cursor_up_position(count=1, preferred_column=original_column)
+            if offset == 0:  # Can't move further up
+                break
+            self.cursor_position += offset
+
         # Remember the original column for the next up/down movement.
         self.preferred_column = original_column
 
@@ -604,6 +787,15 @@ class Buffer(object):
         self.cursor_position += self.document.get_cursor_down_position(
             count=count, preferred_column=original_column)
 
+        # Skip folded lines - keep moving down until we hit a visible line
+        while not self.fold_manager.is_line_visible(self.document.cursor_position_row):
+            if self.document.cursor_position_row >= self.document.line_count - 1:
+                break
+            offset = self.document.get_cursor_down_position(count=1, preferred_column=original_column)
+            if offset == 0:  # Can't move further down
+                break
+            self.cursor_position += offset
+
         # Remember the original column for the next up/down movement.
         self.preferred_column = original_column
 

{rp-0.1.1346 → rp-0.1.1347}/rp/prompt_toolkit/eventloop/base.py

@@ -9,7 +9,7 @@ __all__ = (
 
 
 #: When to trigger the `onInputTimeout` event.
-INPUT_TIMEOUT = .5
+INPUT_TIMEOUT = .1
 
 
 class EventLoop(with_metaclass(ABCMeta, object)):

{rp-0.1.1346 → rp-0.1.1347}/rp/prompt_toolkit/interface.py

@@ -858,11 +858,30 @@ class CommandLineInterface(object):
             if buffer.complete_state or not buffer.completer:
                 return
 
+
+            # Check if result is cached - only run sync if it's a cache hit
+            if hasattr(
+                  buffer.completer, "has_cached_completions"
+            ) and buffer.completer.has_cached_completions(document):
+                # Synchronous completion for auto-complete (cache hit - fast!)
+                completions = list(buffer.completer.get_completions(document, complete_event))
+
+                # When there is only one completion, which has nothing to add, ignore it.
+                if len(completions) == 1 and completion_does_nothing(document, completions[0]):
+                    return
+
+                # Set completions immediately
+                if completions and buffer.text == document.text and buffer.cursor_position == document.cursor_position:
+                    buffer.set_completions(completions=completions, go_to_first=False, go_to_last=False)
+                    self.invalidate()  # trigger redraw
+                return
+
+
             # Otherwise, get completions in other thread.
             complete_thread_running[0] = True
 
             def run():
-                from rp import ring_terminal_bell as ring_terminal_bell
+                # from rp import ring_terminal_bell as ring_terminal_bell
                 completions = list(buffer.completer.get_completions(document, complete_event))
                 # if completions:
                 # ring_terminal_bell()
@@ -882,9 +901,11 @@ class CommandLineInterface(object):
                         del completions[:]
 
                     # Set completions if the text was not yet changed.
+                    # For auto-complete, allow replacing existing completions with fresh results.
+                    # For Tab-complete, only set if no completions exist (original behavior).
                     if buffer.text == document.text and \
                             buffer.cursor_position == document.cursor_position and \
-                            not buffer.complete_state:
+                            (not buffer.complete_state or is_auto_complete):
 
                         set_completions = True
                         select_first_anyway = False
@@ -1191,3 +1212,4 @@ class _SubApplicationEventLoop(EventLoop):
 
     def remove_reader(self, fd):
         self.cli.eventloop.remove_reader(fd)
+

{rp-0.1.1346 → rp-0.1.1347}/rp/prompt_toolkit/key_binding/bindings/vi.py

@@ -1426,6 +1426,82 @@ def load_vi_bindings(get_search_state=None):
 
             w.vertical_scroll = y
 
+    # Folding commands
+    @operator('z', 'f')
+    def _(event, text_object):
+        """
+        Create fold operator. (zf in vim)
+        """
+        buff = event.current_buffer
+        start, end = text_object.operator_range(buff.document)
+
+        # Convert character positions to line numbers
+        start_line = buff.document.translate_index_to_position(start + buff.cursor_position)[0]
+        end_line = buff.document.translate_index_to_position(end + buff.cursor_position)[0]
+
+        # Create the fold (closed by default)
+        if start_line < end_line:
+            buff.fold_manager.add_fold(start_line, end_line, is_open=False)
+
+    @handle('z', 'o', filter=navigation_mode)
+    def _(event):
+        """
+        Open fold at cursor. (zo in vim)
+        """
+        buff = event.current_buffer
+        current_line = buff.document.cursor_position_row
+
+        if not buff.fold_manager.open_fold_at_line(current_line):
+            # If no fold at current line, try to find the fold we're inside
+            fold = buff.fold_manager.get_fold_at_line(current_line)
+            if fold:
+                buff.fold_manager.open_fold_at_line(fold.start_line)
+
+    @handle('z', 'c', filter=navigation_mode)
+    def _(event):
+        """
+        Close fold at cursor. (zc in vim)
+        """
+        buff = event.current_buffer
+        current_line = buff.document.cursor_position_row
+
+        if not buff.fold_manager.close_fold_at_line(current_line):
+            # If no fold at current line, try to find the fold we're inside
+            fold = buff.fold_manager.get_fold_at_line(current_line)
+            if fold:
+                buff.fold_manager.close_fold_at_line(fold.start_line)
+
+    @handle('z', 'a', filter=navigation_mode)
+    def _(event):
+        """
+        Toggle fold at cursor. (za in vim)
+        """
+        buff = event.current_buffer
+        current_line = buff.document.cursor_position_row
+
+        if not buff.fold_manager.toggle_fold_at_line(current_line):
+            # If no fold at current line, try to find the fold we're inside
+            fold = buff.fold_manager.get_fold_at_line(current_line)
+            if fold:
+                buff.fold_manager.toggle_fold_at_line(fold.start_line)
+
+    @handle('z', 'd', filter=navigation_mode)
+    def _(event):
+        """
+        Delete fold at cursor. (zd in vim)
+        """
+        buff = event.current_buffer
+        current_line = buff.document.cursor_position_row
+        buff.fold_manager.remove_fold_at_line(current_line)
+
+    @handle('z', 'E', filter=navigation_mode)
+    def _(event):
+        """
+        Delete all folds. (zE in vim)
+        """
+        buff = event.current_buffer
+        buff.fold_manager.clear()
+
     @text_object('%')
     def _(event):
         """

{rp-0.1.1346 → rp-0.1.1347}/rp/prompt_toolkit/layout/containers.py

@@ -17,6 +17,7 @@ from rp.prompt_toolkit.cache import SimpleCache
 from rp.prompt_toolkit.filters import to_cli_filter, ViInsertMode, EmacsInsertMode
 from rp.prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 from rp.prompt_toolkit.reactive import Integer
+from rp.prompt_toolkit.selection import SelectionType
 from rp.prompt_toolkit.token import Token
 from rp.prompt_toolkit.utils import take_using_weights, get_cwidth
 
@@ -463,7 +464,7 @@ class FloatContainer(Container):
                 height = fl_height
             # Near cursor
             elif fl.ycursor:
-                ypos = cursor_position.y + 1
+                ypos = cursor_position.y + fl.get_ycursor_offset(cli)
 
                 height = fl_height
                 if height is None:
@@ -548,10 +549,11 @@ class Float(object):
 
     :param content: :class:`.Container` instance.
     :param hide_when_covering_content: Hide the float when it covers content underneath.
+    :param ycursor_offset: Offset from cursor position when ycursor=True (default: 1). Can be int or callable.
     """
     def __init__(self, top=None, right=None, bottom=None, left=None,
                  width=None, height=None, get_width=None, get_height=None,
-                 xcursor=False, ycursor=False, content=None,
+                 xcursor=False, ycursor=False, ycursor_offset=1, content=None,
                  hide_when_covering_content=False):
         assert isinstance(content, Container)
         assert width is None or get_width is None
@@ -570,10 +572,17 @@ class Float(object):
 
         self.xcursor = xcursor
         self.ycursor = ycursor
+        self._ycursor_offset = ycursor_offset
 
         self.content = content
         self.hide_when_covering_content = hide_when_covering_content
 
+    def get_ycursor_offset(self, cli):
+        """Get the ycursor offset, evaluating if it's a callable."""
+        if callable(self._ycursor_offset):
+            return self._ycursor_offset(cli)
+        return self._ycursor_offset
+
     def get_width(self, cli):
         if self._width:
             return self._width
@@ -1152,32 +1161,160 @@ class Window(Container):
             y_max=write_position.ypos + write_position.height,
             handler=mouse_handler)
 
-        # Render and copy margins.
+        # Line number margin mouse handler for line selection (like VSCode)
+        def line_number_margin_mouse_handler(cli, mouse_event):
+            """
+            Mouse handler for the line number margin that selects whole lines when
+            clicking/dragging, similar to VSCode behavior.
+            """
+            from .controls import BufferControl
+
+            # Only handle if this is a BufferControl with a buffer
+            if not isinstance(self.content, BufferControl):
+                return NotImplemented
+
+            buffer = self.content._buffer(cli)
+            if not buffer:
+                return NotImplemented
+
+            # Map screen Y coordinate to document row
+            y = mouse_event.position.y
+            max_y = write_position.ypos + len(visible_line_to_row_col) - 1
+            y = min(max_y, y)
+
+            # Get the row number from the visible line mapping
+            relative_y = y - write_position.ypos
+            if relative_y not in visible_line_to_row_col:
+                return NotImplemented
+
+            row, _ = visible_line_to_row_col[relative_y]
+
+            # Calculate cursor position at start of the line
+            line_start_index = buffer.document.translate_row_col_to_index(row, 0)
+
+            if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
+                # Start line selection
+                buffer.cursor_position = line_start_index
+                buffer.start_selection(selection_type=SelectionType.LINES)
+                return None  # Event handled
+
+            elif mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+                # Only continue line selection if drag started in gutter
+                # (indicated by existing LINES selection)
+                if buffer.selection_state and buffer.selection_state.type == SelectionType.LINES:
+                    buffer.cursor_position = line_start_index
+                    return None  # Event handled
+                else:
+                    # Drag started in text area, let text handler handle it
+                    return NotImplemented
+
+            elif mouse_event.event_type == MouseEventType.MOUSE_UP:
+                # Only finalize if this was a gutter drag
+                if buffer.selection_state and buffer.selection_state.type == SelectionType.LINES:
+                    buffer.cursor_position = line_start_index
+                    return None  # Event handled
+                else:
+                    return NotImplemented
+
+            return NotImplemented
+
+        # Render and copy margins, registering mouse handlers for each.
         move_x = 0
+        from rp.prompt_toolkit.layout.margins import FoldMargin
 
         def render_margin(m, width):
-            " Render margin. Return `Screen`. "
+            " Render margin. Return TokenListControl and UIContent. "
             # Retrieve margin tokens.
             tokens = m.create_margin(cli, self.render_info, width, write_position.height)
 
             # Turn it into a UIContent object.
-            # already rendered those tokens using this size.)
-            return TokenListControl.static(tokens).create_content(
-                cli, width + 1, write_position.height)
+            control = TokenListControl.static(tokens)
+            content = control.create_content(cli, width + 1, write_position.height)
+            return control, content
+
+        # Track FoldMargin position to exclude from line selection handler
+        fold_margin_x_min = None
+        fold_margin_x_max = None
 
         for m, width in zip(self.left_margins, left_margin_widths):
             # Create screen for margin.
-            margin_screen = render_margin(m, width)
+            margin_control, margin_screen = render_margin(m, width)
 
             # Copy and shift X.
             self._copy_margin(cli, margin_screen, screen, write_position, move_x, width)
+
+            # Register mouse handler for each margin type
+            if isinstance(m, FoldMargin):
+                # Track fold margin position
+                fold_margin_x_min = write_position.xpos + move_x
+                fold_margin_x_max = write_position.xpos + move_x + width
+
+                # Create a handler that directly toggles folds
+                def make_fold_margin_handler(fold_margin):
+                    def fold_margin_mouse_handler(cli, mouse_event):
+                        # Only handle MOUSE_UP events
+                        if mouse_event.event_type != MouseEventType.MOUSE_UP:
+                            return NotImplemented
+
+                        # Get buffer
+                        if fold_margin.get_buffer:
+                            buffer = fold_margin.get_buffer(cli)
+                        else:
+                            buffer = cli.current_buffer
+
+                        # Map y coordinate to line number
+                        y = mouse_event.position.y - write_position.ypos
+
+                        # Get line number from visible_line_to_row_col
+                        try:
+                            lineno = visible_line_to_row_col[y][0]
+                        except (KeyError, IndexError):
+                            return NotImplemented
+
+                        # Check if this line has a fold
+                        fold = buffer.fold_manager.is_fold_start_line(lineno)
+                        if fold:
+                            # Toggle the fold
+                            fold.is_open = not fold.is_open
+                            return None  # Event handled
+
+                        return NotImplemented
+                    return fold_margin_mouse_handler
+
+                mouse_handlers.set_mouse_handler_for_range(
+                    x_min=write_position.xpos + move_x,
+                    x_max=write_position.xpos + move_x + width,
+                    y_min=write_position.ypos,
+                    y_max=write_position.ypos + write_position.height,
+                    handler=make_fold_margin_handler(m))
+
             move_x += width
 
+        # Register line number selection handler for non-FoldMargin area
+        if left_margin_widths:
+            # Calculate the area excluding FoldMargin
+            if fold_margin_x_min is not None:
+                # Line numbers are after the fold margin
+                line_num_x_min = fold_margin_x_max
+                line_num_x_max = write_position.xpos + sum(left_margin_widths)
+            else:
+                # No fold margin, use entire left margin area
+                line_num_x_min = write_position.xpos
+                line_num_x_max = write_position.xpos + sum(left_margin_widths)
+
+            if line_num_x_min < line_num_x_max:
+                mouse_handlers.set_mouse_handler_for_range(
+                    x_min=line_num_x_min,
+                    x_max=line_num_x_max,
+                    y_min=write_position.ypos,
+                    y_max=write_position.ypos + write_position.height,
+                    handler=line_number_margin_mouse_handler)
+
         move_x = write_position.width - sum(right_margin_widths)
 
         for m, width in zip(self.right_margins, right_margin_widths):
             # Create screen for margin.
-            margin_screen = render_margin(m, width)
+            margin_control, margin_screen = render_margin(m, width)
 
             # Copy and shift X.
             self._copy_margin(cli, margin_screen, screen, write_position, move_x, width)
@@ -1220,6 +1357,11 @@ class Window(Container):
                 # Take the next line and copy it in the real screen.
                 line = ui_content.get_line(lineno)
 
+                # Skip lines that return None (e.g., folded lines)
+                if line is None:
+                    lineno += 1
+                    continue
+
                 col = 0
                 x = -horizontal_scroll
 

{rp-0.1.1346 → rp-0.1.1347}/rp/prompt_toolkit/layout/controls.py

@@ -634,13 +634,39 @@ class BufferControl(UIControl):
         get_processed_line = self._create_get_processed_line_func(cli, document)
         self._last_get_processed_line = get_processed_line
 
+        # Handle folding: keep full line_count but return None for hidden lines
+        fold_manager = buffer.fold_manager
+
         def translate_rowcol(row, col):
             " Return the content column for this coordinate. "
             return Point(y=row, x=get_processed_line(row).source_to_display(col))
 
-        def get_line(i):
-            " Return the tokens for a given line number. "
-            tokens = get_processed_line(i).tokens
+        def get_line(logical_line):
+            " Return the tokens for a given logical line number (accounting for folds). "
+            from rp.prompt_toolkit.token import Token
+
+            # Check if this line is hidden inside a fold (not the fold start line)
+            if not fold_manager.is_line_visible(logical_line):
+                # Return None to signal this line should be skipped in rendering
+                return None
+
+            # Check if this line starts a closed fold
+            fold = fold_manager.get_fold_at_line(logical_line)
+            is_fold_start = fold and fold.start_line == logical_line and not fold.is_open
+
+            if is_fold_start:
+                # Show fold line with prefix and suffix
+                num_folded_lines = fold.end_line - fold.start_line
+
+                # Get the original line content
+                original_tokens = get_processed_line(logical_line).tokens
+
+                # Build the folded line display: "››››› [content] | N lines |"
+                tokens = [(Token.Folded.Prefix, '››››› ')]
+                tokens.extend(original_tokens)
+                tokens.append((Token.Folded.Suffix, ' | %d lines |' % num_folded_lines))
+            else:
+                tokens = get_processed_line(logical_line).tokens
 
             # Add a space at the end, because that is a possible cursor
             # position. (When inserting after the input.) We should do this on
@@ -650,11 +676,17 @@ class BufferControl(UIControl):
             tokens = tokens + [(self.default_char.token, ' ')]
             return tokens
 
+        # Calculate cursor position - if cursor is in a folded region, move it to the fold line
+        cursor_row = document.cursor_position_row
+        if not fold_manager.is_line_visible(cursor_row):
+            fold = fold_manager.get_fold_at_line(cursor_row)
+            if fold:
+                cursor_row = fold.start_line
+
         content = UIContent(
             get_line=get_line,
             line_count=document.line_count,
-            cursor_position=translate_rowcol(document.cursor_position_row,
-                                             document.cursor_position_col),
+            cursor_position=translate_rowcol(cursor_row, document.cursor_position_col),
             default_char=self.default_char)
 
         # If there is an auto completion going on, use that start point for a