robotcode-repl 2.6.2__py3-none-any.whl → 2.8.0__py3-none-any.whl

robotcode/repl/Repl/repl.py

@@ -1,6 +1,9 @@
 import sys
 
+from robot.errors import ExecutionFailures
+
 from ..__version__ import __version__
+from ..base_interpreter import take_active_interpreter
 
 
 class Repl:
@@ -18,8 +21,14 @@ class Repl:
         """Internal marker keyword that opens the interactive REPL prompt.
 
         Called by the synthetic suite ``robotcode repl`` runs; not meant to be
-        used directly in your own tests.
+        used directly in your own tests. Once the prompt is left, it fails with
+        the failures ``robotcode repl`` recorded during the session, so the
+        session test reflects them.
         """
+        # The prompt loop ran while this keyword started; its body runs after it.
+        interpreter = take_active_interpreter()
+        if interpreter is not None and interpreter.failures:
+            raise ExecutionFailures(interpreter.failures)
 
     def breakpoint(self) -> None:
         """No-op marker keyword: the RobotCode debugger pauses here when attached.

robotcode/repl/__version__.py

@@ -1 +1 @@
-__version__ = "2.6.2"
+__version__ = "2.8.0"

robotcode/repl/_debug/controller.py

@@ -12,16 +12,18 @@ import contextlib
 import re
 import reprlib
 import weakref
+from functools import lru_cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Iterable, Iterator, List, Mapping, Optional, Set
 
 from robot.running.context import EXECUTION_CONTEXTS
+from robot.utils import Matcher
 from robot.variables import evaluate_expression
 
 from robotcode.core.utils.path import normalized_path
 from robotcode.robot.utils import RF_VERSION
 
-from ..base_interpreter import result_qualified_name
+from ..base_interpreter import result_definition_names, result_qualified_name
 from .types import (
     Breakpoint,
     DebugTerminated,
@@ -71,6 +73,15 @@ _CATCHING_KEYWORDS = frozenset(
     }
 )
 
+
+@lru_cache(maxsize=None)
+def _keyword_matcher(name: str) -> Matcher:
+    """A keyword breakpoint's name as Robot Framework matches keyword names in
+    `--removekeywords name:`: ignoring case, spaces and underscores, with the
+    glob patterns `*`, `?` and `[chars]`."""
+    return Matcher(name, ignore="_")
+
+
 # The `Breakpoint` marker keyword from `robotcode.repl.Repl` (see Repl/repl.py):
 # the debugger stops where it runs. Its qualified name is stable across RF 5/6/7.
 _BREAKPOINT_MARKER = "robotcode.repl.Repl.Breakpoint"
@@ -119,6 +130,8 @@ class DebugController:
         self._next_bp_id = 1
         # the breakpoint matched at the current stop (for `.commands` replay)
         self._stopped_breakpoint: Optional[Breakpoint] = None
+        # why that breakpoint's condition couldn't be evaluated, shown in the stop line
+        self._condition_error = ""
 
         # stepping / pause state
         self._stepping: Optional[ResumeAction] = None
@@ -241,6 +254,15 @@ class DebugController:
         """Pause at the next executed keyword (on-demand pause)."""
         self._pause_requested = True
 
+    def cancel_pause(self) -> None:
+        """Drop a pause request that hasn't stopped yet."""
+        self._pause_requested = False
+
+    @property
+    def pause_requested(self) -> bool:
+        """Whether a pause request waits for the next executed keyword."""
+        return self._pause_requested
+
     @property
     def stack(self) -> List[StackFrame]:
         """Current call stack, outermost frame first."""
@@ -439,7 +461,7 @@ class DebugController:
 
         reason = self._stop_reason(frame)
         if reason is not None:
-            self._pause(reason, frame)
+            self._pause(reason, frame, self._condition_error if reason == StopReason.BREAKPOINT else "")
 
     def end_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
         if not self._stack:
@@ -614,6 +636,7 @@ class DebugController:
         logpoint emit (log + continue), one-shot removal; records the matched
         breakpoint in `_stopped_breakpoint` for the front-end (`.commands`)."""
         self._stopped_breakpoint = None
+        self._condition_error = ""
         if frame.name == _BREAKPOINT_MARKER:  # embedded `Breakpoint` keyword
             return True
         bp = self._match_breakpoint(frame)
@@ -624,8 +647,17 @@ class DebugController:
                 triggered = bool(self.evaluate_expression(frame, bp.condition))
             except (SystemExit, KeyboardInterrupt):
                 raise
-            except BaseException:
-                triggered = True  # a failing condition stops, so it gets noticed
+            except BaseException as e:
+                # A failing condition stops right away, so it gets noticed: past the
+                # ignore count and keeping a temporary breakpoint (pdb semantics).
+                # A logpoint never stops; it reports the error instead.
+                self._condition_error = f"condition error: {str(e) or type(e).__name__}"
+                if bp.log_message is not None:
+                    if self._frontend is not None:
+                        self._frontend.on_output(self._condition_error)
+                    return False
+                self._stopped_breakpoint = bp
+                return True
             if not triggered:
                 return False
         bp.hits += 1
@@ -643,7 +675,7 @@ class DebugController:
         for bp in self._breakpoints:
             if not bp.enabled:
                 continue
-            if bp.kind == "keyword" and bp.name in (frame.short_name, frame.name):
+            if bp.kind == "keyword" and bp.name is not None and self._keyword_matches(bp.name, frame):
                 return bp
             if (
                 bp.kind == "line"
@@ -655,6 +687,13 @@ class DebugController:
                 return bp
         return None
 
+    @staticmethod
+    def _keyword_matches(name: str, frame: StackFrame) -> bool:
+        if frame.type not in _KEYWORD_FRAME_TYPES:
+            return False
+        matcher = _keyword_matcher(name)
+        return bool(matcher.match_any((frame.name, frame.short_name, *frame.definition_names)))
+
     def _emit_logpoint(self, frame: StackFrame, message: str) -> None:
         try:
             text = self._frame_store(frame).replace_string(message)
@@ -666,6 +705,8 @@ class DebugController:
             self._frontend.on_output(text)
 
     def _pause(self, reason: StopReason, frame: StackFrame, description: str = "") -> None:
+        # Any stop answers a pending pause request; it must not stop the run once more.
+        self._pause_requested = False
         if self._frontend is None:
             # No UI attached: keep running (don't block).
             self._stepping = None
@@ -736,4 +777,5 @@ class DebugController:
             executed=(status != _NOT_RUN),
             context=context_ref,
             variables=variables_ref,
+            definition_names=result_definition_names(result),
         )

robotcode/repl/_debug/types.py

@@ -2,7 +2,7 @@
 
 import enum
 from dataclasses import dataclass, field
-from typing import Any, List, Optional, Protocol, runtime_checkable
+from typing import Any, List, Optional, Protocol, Tuple, runtime_checkable
 
 
 class DebugTerminated(BaseException):
@@ -53,6 +53,9 @@ class StackFrame:
     executed: bool = True
     context: Any = field(default=None, repr=False, compare=False)
     variables: Any = field(default=None, repr=False, compare=False)
+    # For a keyword with embedded arguments, its definition name (`Select ${animal}
+    # From List`), bare and qualified; empty for other frames.
+    definition_names: Tuple[str, ...] = ()
 
     @property
     def short_name(self) -> str:
@@ -66,8 +69,8 @@ class Breakpoint:
 
     `kind` is ``"line"`` (`source`+`line`) or ``"keyword"`` (`name`). The optional
     attributes drive the hit-time decision: `condition` (stop only if the
-    expression is truthy — a *failing* condition stops too, so the breakage is
-    noticed), `ignore_count` (skip the next N triggering hits), `log_message`
+    expression is truthy — a *failing* condition stops too, past `ignore_count`
+    and `temporary`, so the breakage is noticed), `ignore_count` (skip the next N triggering hits), `log_message`
     (logpoint: log + continue, never stop), `temporary` (remove after it stops),
     `commands` (debugger commands replayed at the hit). `id` is a stable number
     for referencing the breakpoint (`.condition 2`, `.delete 2`, …).

robotcode/repl/_indent.py

@@ -4,7 +4,8 @@ Pure-Python, deterministic, no Robot-runtime dependency. Used by:
 
 - `ConsoleInterpreter.get_input()` to pre-compute the indent string
   passed via `prefill=` to the next `read_line()` call (so the
-  continuation prompt seeds the user's cursor at the right column).
+  continuation prompt seeds the user's cursor at the right column),
+  and to spot a fresh input that starts with a continuation line.
 - `_pt.components` smart-Enter / Shift-Enter key bindings to decide
   whether the buffer still has an open block and what indent the
   inserted newline should carry.
@@ -80,3 +81,9 @@ def has_open_block(text: str) -> bool:
     block openers than closers — i.e. would not be a complete Robot
     statement if submitted as-is."""
     return _block_depth(text.splitlines()) > 0
+
+
+def starts_with_continuation(text: str) -> bool:
+    """True if the first line of `text` is a continuation line — its first
+    cell is Robot's ``...`` marker."""
+    return _first_cell(text.split("\n", 1)[0]) == "..."

robotcode/repl/_pt/components.py

@@ -15,6 +15,7 @@ from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.completion import CompleteEvent, Completer, Completion
 from prompt_toolkit.document import Document
 from prompt_toolkit.filters import has_completions
+from prompt_toolkit.formatted_text import StyleAndTextTuples
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from prompt_toolkit.styles import Style
@@ -404,7 +405,7 @@ def _render_signature(name: str, spec: Any, active: int) -> List[Tuple[str, str]
     return parts
 
 
-def _bottom_toolbar() -> Optional[List[Tuple[str, str]]]:
+def _bottom_toolbar() -> Optional[StyleAndTextTuples]:
     """Bottom status line — keyword signature when the cursor sits in an
     argument cell, else nothing (the bar is hidden).