robotcode-repl 2.9.0.dev87__tar.gz → 2.9.0.dev124__tar.gz

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-repl
-Version: 2.9.0-dev.87
+Version: 2.9.0-dev.124
 Summary: RobotCode REPL for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -27,7 +27,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: prompt-toolkit!=3.0.52
-Requires-Dist: robotcode-runner==2.9.0-dev.87
+Requires-Dist: robotcode-runner==2.9.0-dev.124
 Description-Content-Type: text/markdown
 
 # robotcode-repl

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/pyproject.toml

@@ -29,7 +29,7 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-  "robotcode-runner==2.9.0-dev.87",
+  "robotcode-runner==2.9.0-dev.124",
   "prompt_toolkit!=3.0.52"
 ]
 

robotcode_repl-2.9.0.dev124/src/robotcode/repl/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.9.0-dev.124"

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/_debug/controller.py

@@ -121,6 +121,22 @@ def _normalize_source(source: str) -> str:
     return str(normalized_path(Path(source)))
 
 
+def _breakpoint_source(source: str) -> str:
+    """What a line breakpoint matches by: a path with a root or a drive, or one that leaves the folder with `..`,
+    as an absolute path; any other as it is, see `_source_matches`."""
+    path = Path(source)
+    return _normalize_source(source) if path.anchor or ".." in path.parts else str(path)
+
+
+def _source_matches(source: str, frame_source: str) -> bool:
+    """Whether a line breakpoint means the file of a frame: an absolute path exactly, any other by the
+    end of the path, as in gdb, so that `login.robot` finds `tests/login.robot`."""
+    given, actual = Path(source), Path(frame_source)
+    if given.is_absolute():
+        return given == actual
+    return Path(*actual.parts[-len(given.parts) :]) == given
+
+
 class DebugController:
     def __init__(self, frontend: Optional[Frontend] = None) -> None:
         self._stack: List[StackFrame] = []
@@ -159,6 +175,9 @@ class DebugController:
         # breakpoints/filters are kept so re-attaching resumes the same setup.
         self._detached = False
 
+        # set for a run that goes through a suite: at its end, say which breakpoints no keyword reached.
+        self._warn_about_unreached = False
+
     # --- configuration ------------------------------------------------------
 
     def set_frontend(self, frontend: Optional[Frontend]) -> None:
@@ -181,7 +200,8 @@ class DebugController:
     ) -> Breakpoint:
         return self._add_breakpoint(
             kind="line",
-            source=_normalize_source(source),
+            source=_breakpoint_source(source),
+            location=source,
             line=line,
             condition=condition,
             log_message=log_message,
@@ -202,7 +222,7 @@ class DebugController:
 
     def set_line_breakpoints(self, source: str, lines: List[int]) -> None:
         """Replace the line breakpoints for `source` (DAP-style per-source set)."""
-        norm = _normalize_source(source)
+        norm = _breakpoint_source(source)
         self._breakpoints = [bp for bp in self._breakpoints if not (bp.kind == "line" and bp.source == norm)]
         for line in lines:
             self.add_line_breakpoint(source, line)
@@ -213,6 +233,11 @@ class DebugController:
         for name in names:
             self.add_keyword_breakpoint(name)
 
+    def warn_about_unreached_breakpoints(self) -> None:
+        """Warn at the end of the run about the breakpoints no keyword reached: from the outside, a mistyped
+        path looks like a run that simply went through."""
+        self._warn_about_unreached = True
+
     def get_breakpoint(self, bp_id: int) -> Optional[Breakpoint]:
         return next((bp for bp in self._breakpoints if bp.id == bp_id), None)
 
@@ -230,7 +255,7 @@ class DebugController:
     def restore_breakpoints(self, state: BreakpointState) -> None:
         """Take over the breakpoints of `breakpoint_state`, in place of those set so far. Their hit counts start at 0,
         as `.ignore` counts the hits of a run."""
-        self._breakpoints = [dataclasses.replace(bp, hits=0) for bp in state.breakpoints]
+        self._breakpoints = [dataclasses.replace(bp, hits=0, reached=False) for bp in state.breakpoints]
         self._next_bp_id = state.next_id
         self._exception_filters = set(state.exception_filters)
 
@@ -288,7 +313,7 @@ class DebugController:
 
     @property
     def line_breakpoints(self) -> Dict[str, Set[int]]:
-        """Active line breakpoints, keyed by normalised source path (derived)."""
+        """Active line breakpoints, keyed by the path they match by (derived)."""
         out: Dict[str, Set[int]] = {}
         for bp in self._breakpoints:
             if bp.kind == "line" and bp.source is not None and bp.line is not None:
@@ -551,6 +576,10 @@ class DebugController:
 
     def end_suite(self, data: "running.TestSuite", result: "result.TestSuite") -> None:
         self._end_exec(result, "failed_suite")
+        if self._warn_about_unreached and not self._stack and not self._detached and self._frontend is not None:
+            for bp in self._breakpoints:
+                if bp.enabled and not bp.reached:
+                    self._frontend.on_output(f"[ WARN ] Breakpoint {bp.where} was never reached.")
 
     def _end_exec(self, result: Any, filter_id: str) -> None:
         # The SUITE/TEST frame pushed at the matching start is on top of the stack.
@@ -685,20 +714,24 @@ class DebugController:
         return True
 
     def _match_breakpoint(self, frame: StackFrame) -> Optional[Breakpoint]:
+        matched: Optional[Breakpoint] = None
         for bp in self._breakpoints:
-            if not bp.enabled:
-                continue
-            if bp.kind == "keyword" and bp.name is not None and self._keyword_matches(bp.name, frame):
-                return bp
-            if (
-                bp.kind == "line"
-                and frame.source is not None
-                and frame.line is not None
-                and bp.source == _normalize_source(frame.source)
-                and bp.line == frame.line
-            ):
-                return bp
-        return None
+            if bp.enabled and self._is_at_breakpoint(bp, frame):
+                # Whether its condition holds or not: the warning is about the place.
+                bp.reached = True
+                matched = matched or bp
+        return matched
+
+    def _is_at_breakpoint(self, bp: Breakpoint, frame: StackFrame) -> bool:
+        if bp.kind == "keyword":
+            return bp.name is not None and self._keyword_matches(bp.name, frame)
+        return (
+            frame.source is not None
+            and frame.line is not None
+            and bp.source is not None
+            and bp.line == frame.line
+            and _source_matches(bp.source, _normalize_source(frame.source))
+        )
 
     @staticmethod
     def _keyword_matches(name: str, frame: StackFrame) -> bool:

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/_debug/types.py

@@ -67,7 +67,8 @@ class StackFrame:
 class Breakpoint:
     """A registered breakpoint with optional attributes (the shared CLI + DAP model).
 
-    `kind` is ``"line"`` (`source`+`line`) or ``"keyword"`` (`name`). The optional
+    `kind` is ``"line"`` (`source`+`line`, with `location` as it was given) or
+    ``"keyword"`` (`name`). The optional
     attributes drive the hit-time decision: `condition` (stop only if the
     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`
@@ -88,6 +89,13 @@ class Breakpoint:
     enabled: bool = True
     commands: List[str] = field(default_factory=list)
     hits: int = 0
+    location: Optional[str] = None
+    reached: bool = False
+
+    @property
+    def where(self) -> str:
+        """Where the breakpoint was set, as it was given."""
+        return f"{self.name}" if self.kind == "keyword" else f"{self.location}:{self.line}"
 
 
 @dataclass

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/_pt/doc_viewer.py

@@ -59,7 +59,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 from robot.utils import MultiMatcher
 
-from robotcode.robot.utils.markdown_docs import heading_anchors
+from robotcode.robot.utils.markdown_docs import code_lines_before_headings, heading_anchors
 
 
 def render_markdown_to_ansi(text: str, *, width: int = 80) -> str:
@@ -240,12 +240,12 @@ _SIDEBAR_HINTS = " type: filter · ↑/↓: select · wheel: scroll · Enter or
 # The rendered-line lookup runs a heading's title through `_strip_md_emphasis`
 # because `rich` consumes those markers when it paints.
 
-_MD_EMPHASIS_RE = re.compile(r"[*_`]")
+_MD_EMPHASIS_RE = re.compile(r"\\([!-/:-@\[-`{-~])|[*_`]")
 
 
 def _strip_md_emphasis(text: str) -> str:
-    """Drop `*`, `_`, `` ` `` markers — `rich` consumes them in rendering."""
-    return _MD_EMPHASIS_RE.sub("", text)
+    """Drop `*`, `_`, `` ` `` markers and the backslash of escapes — `rich` consumes them in rendering."""
+    return _MD_EMPHASIS_RE.sub(lambda m: m.group(1) or "", text)
 
 
 def _build_anchor_to_line_map(md_source: str, rendered_plain: str) -> Dict[str, int]:
@@ -267,10 +267,15 @@ def _build_anchor_to_line_map(md_source: str, rendered_plain: str) -> Dict[str,
     cursor = 0
     # `heading_anchors` skips `#` lines of fenced code blocks, which are no headings,
     # and numbers repeated anchors as the links of the page do
-    for _, raw_title, anchor in heading_anchors(md_source):
+    for (_, raw_title, anchor), code_lines in zip(heading_anchors(md_source), code_lines_before_headings(md_source)):
         display = _strip_md_emphasis(raw_title)
+        # a line of a code block can read like the heading after it
+        skip = code_lines.count(display)
         for j in range(cursor, len(rendered_lines)):
             if rendered_lines[j].strip() == display:
+                if skip:
+                    skip -= 1
+                    continue
                 result[anchor] = j
                 cursor = j + 1
                 break

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/_session.py

@@ -1178,7 +1178,7 @@ class SessionInterpreter(ConsoleInterpreter):
     @property
     def termination_requested(self) -> bool:
         """Whether a signal has asked the REPL or the run to end, as SIGTERM does."""
-        return self._termination_requested
+        return self._termination_requested and not self._aborted
 
     def read_line(
         self, prompt: str, *, multiline_continuation: bool = False, prefill: str = "", completer: Any = None
@@ -1221,6 +1221,10 @@ class SessionInterpreter(ConsoleInterpreter):
         if not self._server.at_line_start():
             super()._end_console_line()
 
+    def _dot_command_failed(self, text: str) -> None:
+        self._server.line_failed()
+        super()._dot_command_failed(text)
+
     def _evaluate_at_stop(self, line: str) -> bool:
         # A keyword at a stop fails the input as at the REPL prompt.
         try:

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/base_interpreter.py

@@ -436,6 +436,8 @@ class BaseInterpreter(abc.ABC):
         self.exit_code: Optional[int] = None
         # Set by a signal that ends the session or the run.
         self._termination_requested = False
+        # Set by `.abort`, which ends the run by the same way as a signal but isn't one from outside.
+        self._aborted = False
         # Set while a statement of the input runs: SIGTERM then stops it at its next keyword.
         self._running_statement = False
 

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/cli.py

@@ -460,8 +460,8 @@ DEBUG_OPTIONS = [
         "break_at",
         metavar="LOCATION",
         multiple=True,
-        help="Break at LOCATION — a `file:line`, or a keyword name or glob pattern "
-        "matched like Robot Framework. Repeatable.",
+        help="Break at LOCATION — a `file:line`, where the end of the path is enough, or a keyword name "
+        "or glob pattern matched like Robot Framework. Repeatable.",
     ),
     click.option(
         "--break-on-exception/--no-break-on-exception",
@@ -694,6 +694,7 @@ def robot_debug(
     )
     if server is not None:
         server.keep_breakpoints(controller)
+    controller.warn_about_unreached_breakpoints()
 
     # `robot-debug` produces the same console output as `robotcode robot` — the run
     # is fully visible. At a stop the debug prompt is interleaved with Robot's live
@@ -704,14 +705,20 @@ def robot_debug(
     session: ContextManager[object] = server if server is not None else contextlib.nullcontext()
     try:
         with session, interpreter.forward_events(echo_messages=False):
-            _invoke_runner(
-                ctx,
-                by_longname,
-                exclude_by_longname,
-                by_test_metadata,
-                exclude_by_test_metadata,
-                robot_options_and_args,
-            )
+            try:
+                _invoke_runner(
+                    ctx,
+                    by_longname,
+                    exclude_by_longname,
+                    by_test_metadata,
+                    exclude_by_test_metadata,
+                    robot_options_and_args,
+                )
+            except SystemExit:
+                # After `.abort` the code says that, not how many tests failed.
+                if interpreter.exit_code is None:
+                    raise
+                raise SystemExit(interpreter.exit_code) from None
     except DebugTerminated:
         app.echo("Debugger: run terminated.")
     finally:

{robotcode_repl-2.9.0.dev87 → robotcode_repl-2.9.0.dev124}/src/robotcode/repl/console_interpreter.py

@@ -21,6 +21,7 @@ import pprint
 import re
 import reprlib
 import shlex
+import signal
 import sys
 from datetime import datetime
 from pathlib import Path
@@ -31,6 +32,7 @@ from robot import result, running
 from robot.errors import ExecutionFailed, ExecutionPassed, ExecutionStatus
 from robot.running import Keyword
 from robot.running.context import EXECUTION_CONTEXTS
+from robot.running.signalhandler import STOP_SIGNAL_MONITOR
 from robot.utils import normalize
 
 from robotcode.plugin import Application
@@ -471,8 +473,7 @@ class ConsoleInterpreter(BaseInterpreter):
         arg = (m.group(2) or "").strip()
         attr_name, error = self._resolve_dot_command(name)
         if attr_name is None:
-            if self.app is not None:
-                self.app.echo(error or f"Unknown dot-command: .{name}. Try .help.")
+            self._dot_command_failed(error or f"Unknown dot-command: .{name}. Try .help.")
             return True
         getattr(self, attr_name)(arg)
         return True
@@ -667,9 +668,9 @@ class ConsoleInterpreter(BaseInterpreter):
         silent = bool(bp is not None and bp.commands and bp.commands[0] == "silent" and not stop.description)
         if not silent:
             self._render_stop(stop)
-        # try/finally so the stop state is always cleared, even if `.abort`
-        # (SystemExit) or a Ctrl-C during an at-stop evaluation unwinds through
-        # the loop — otherwise a stale `_stop` would leave the interactive shell
+        # try/finally so the stop state is always cleared, even if a Ctrl-C
+        # during an at-stop evaluation unwinds through the loop — otherwise a
+        # stale `_stop` would leave the interactive shell
         # prompt wedged in a phantom debug state after the run returns.
         try:
             if bp is not None and bp.commands:
@@ -698,9 +699,9 @@ class ConsoleInterpreter(BaseInterpreter):
                     # already; the REPL prompt adds nothing to it either.
                     pass
                 except Exception as e:  # a throwing command must not eject the debug prompt
-                    # `.abort` (SystemExit), Ctrl-C, and DebugTerminated are
-                    # BaseException, not Exception, so they still propagate.
-                    self._echo(f"! {e}")
+                    # Ctrl-C and DebugTerminated are BaseException, not
+                    # Exception, so they still propagate.
+                    self._dot_command_failed(f"! {e}")
             return self._pending_action
         finally:
             self._stop = None
@@ -736,10 +737,14 @@ class ConsoleInterpreter(BaseInterpreter):
         if self.app is not None:
             self.app.echo(text)
 
+    def _dot_command_failed(self, text: str) -> None:
+        """Say that a dot-command couldn't do what was asked."""
+        self._echo(text)
+
     def _require_stop(self) -> bool:
         """Guard for commands that only mean something while paused."""
         if self._stop is None:
-            self._echo("not at a breakpoint")
+            self._dot_command_failed("not at a breakpoint")
             return False
         return True
 
@@ -747,7 +752,7 @@ class ConsoleInterpreter(BaseInterpreter):
         """Guard for commands that need a wired debug controller. (Distinct from
         the attach/detach *state* — a detached controller is still wired.)"""
         if self._controller is None:
-            self._echo("no debugger available")
+            self._dot_command_failed("no debugger available")
             return False
         return True
 
@@ -1377,12 +1382,12 @@ class ConsoleInterpreter(BaseInterpreter):
         if self.app is None:
             return
         if not arg:
-            self.app.echo("Usage: .doc <library-or-resource-name>")
+            self._dot_command_failed("Usage: .doc <library-or-resource-name>")
             return
 
         lib_doc, error = self._resolve_doc_target(arg)
         if lib_doc is None:
-            self.app.echo(error or f"Could not load {arg!r}.")
+            self._dot_command_failed(error or f"Could not load {arg!r}.")
             return
 
         self.show_doc(
@@ -1445,7 +1450,7 @@ class ConsoleInterpreter(BaseInterpreter):
         try:
             self.app.echo(str(Path.cwd()))
         except OSError as e:
-            self.app.echo(f"(working directory unavailable: {e})")
+            self._dot_command_failed(f"(working directory unavailable: {e})")
 
     @dot_command("exit", "quit")
     def _exit(self, arg: str) -> None:
@@ -1465,13 +1470,13 @@ class ConsoleInterpreter(BaseInterpreter):
           .exit 3
         """
         if self._stop is not None:
-            self._echo("at a debug stop — use .continue or .detach to resume, or .abort to quit the run")
+            self._dot_command_failed("at a debug stop — use .continue or .detach to resume, or .abort to quit the run")
             return
         if arg:
             try:
                 self.exit_code = int(arg)
             except ValueError:
-                self._echo("Usage: .exit [CODE]")
+                self._dot_command_failed("Usage: .exit [CODE]")
                 return
         raise EOFError
 
@@ -1515,7 +1520,7 @@ class ConsoleInterpreter(BaseInterpreter):
         try:
             opts = parser.parse_args(_split_command_args(arg))
         except (argparse.ArgumentError, SystemExit, ValueError):
-            self.app.echo("Usage: .save [-a] [-t NAME] [--keep-failed] FILENAME")
+            self._dot_command_failed("Usage: .save [-a] [-t NAME] [--keep-failed] FILENAME")
             return
 
         recorded: List[str] = list(self._session_lines or [])
@@ -1541,7 +1546,7 @@ class ConsoleInterpreter(BaseInterpreter):
             else:
                 path.write_text(content, encoding="utf-8")
         except OSError as e:
-            self.app.echo(f"Could not write {opts.filename}: {e}")
+            self._dot_command_failed(f"Could not write {opts.filename}: {e}")
             return
 
         summary = f"{len(lines)} {'entry' if len(lines) == 1 else 'entries'}"
@@ -1656,7 +1661,7 @@ class ConsoleInterpreter(BaseInterpreter):
         (default 10) — `.source Open Browser 25`.
         """
         if not arg:
-            self._echo("usage: .source <keyword-name> [lines]")
+            self._dot_command_failed("usage: .source <keyword-name> [lines]")
             return
         # Split off a trailing line-count (the plain-backend window size). Keyword
         # names contain spaces, so only a trailing integer token counts.
@@ -1666,7 +1671,7 @@ class ConsoleInterpreter(BaseInterpreter):
             name, count = head[0], max(1, int(head[1]))
         found = lookup_keyword_owner(name)
         if found is None:
-            self._echo(f"keyword {name!r} not found")
+            self._dot_command_failed(f"keyword {name!r} not found")
             return
         owner, runtime_kw, is_resource = found
         kw_name = getattr(runtime_kw, "name", name)
@@ -1676,7 +1681,7 @@ class ConsoleInterpreter(BaseInterpreter):
         if source is None:
             source = getattr(runtime_kw, "source", None)
         if source is None or line is None:
-            self._echo(f"(no source available for {kw_name})")
+            self._dot_command_failed(f"(no source available for {kw_name})")
             return
         source, line = str(source), int(line)
         header = f"{kw_name}  ({os.path.basename(source)}:{line})"
@@ -1707,7 +1712,7 @@ class ConsoleInterpreter(BaseInterpreter):
             target = int(arg)
         except ValueError:
             top = len(self._stop.stack) - 1 if self._stop else 0
-            self._echo(f"usage: .frame <n>  (0..{top})")
+            self._dot_command_failed(f"usage: .frame <n>  (0..{top})")
             return
         self._move_frame(target)
 
@@ -1717,12 +1722,12 @@ class ConsoleInterpreter(BaseInterpreter):
         if not self._require_stop():
             return
         if not arg:
-            self._echo("usage: .print <variable-or-expression>")
+            self._dot_command_failed("usage: .print <variable-or-expression>")
             return
         try:
             value = self._controller.evaluate_expression(self._selected_frame(), arg)  # type: ignore[union-attr]
         except Exception as e:  # surface lookup/eval failures to the prompt
-            self._echo(f"! {e}")
+            self._dot_command_failed(f"! {e}")
             return
         self._echo(f"{arg} = {_repr.repr(value)}")
 
@@ -1732,12 +1737,12 @@ class ConsoleInterpreter(BaseInterpreter):
         if not self._require_stop():
             return
         if not arg:
-            self._echo("usage: .pprint <variable-or-expression>")
+            self._dot_command_failed("usage: .pprint <variable-or-expression>")
             return
         try:
             value = self._controller.evaluate_expression(self._selected_frame(), arg)  # type: ignore[union-attr]
         except Exception as e:  # surface lookup/eval failures to the prompt
-            self._echo(f"! {e}")
+            self._dot_command_failed(f"! {e}")
             return
         self._echo(pprint.pformat(value))
 
@@ -1747,12 +1752,12 @@ class ConsoleInterpreter(BaseInterpreter):
         if not self._require_stop():
             return
         if not arg:
-            self._echo("usage: .whatis <variable-or-expression>")
+            self._dot_command_failed("usage: .whatis <variable-or-expression>")
             return
         try:
             value = self._controller.evaluate_expression(self._selected_frame(), arg)  # type: ignore[union-attr]
         except Exception as e:  # surface lookup/eval failures to the prompt
-            self._echo(f"! {e}")
+            self._dot_command_failed(f"! {e}")
             return
         self._echo(f"{arg}: {type(value).__name__}")
 
@@ -1784,7 +1789,7 @@ class ConsoleInterpreter(BaseInterpreter):
             self._display_exprs.remove(arg)
             self._echo(f"no longer displaying {arg}")
         else:
-            self._echo(f"not displaying: {arg}")
+            self._dot_command_failed(f"not displaying: {arg}")
 
     @dot_command("set", group="Debugger")
     def _set(self, arg: str) -> None:
@@ -1803,18 +1808,18 @@ class ConsoleInterpreter(BaseInterpreter):
             return
         parts = arg.split(None, 1)
         if len(parts) < 2:
-            self._echo("usage: .set ${name} <value>")
+            self._dot_command_failed("usage: .set ${name} <value>")
             return
         name, value = parts[0], parts[1]
         if not (name.startswith("${") and name.endswith("}")) or "[" in name:
-            self._echo(f"! .set only supports whole scalar variables (${{...}}), not {name}")
+            self._dot_command_failed(f"! .set only supports whole scalar variables (${{...}}), not {name}")
             return
         try:
             new_repr = self._controller.set_variable(  # type: ignore[union-attr]
                 self._selected_frame(), name, value, evaluate=False
             )
         except Exception as e:  # surface NameError / unknown-variable to the prompt
-            self._echo(f"! {e}")
+            self._dot_command_failed(f"! {e}")
             return
         self._echo(f"{name} = {new_repr}")
 
@@ -1822,7 +1827,7 @@ class ConsoleInterpreter(BaseInterpreter):
         if not self._require_controller():
             return
         if not arg:
-            self._echo("usage: .break <file:line | keyword name> [, <condition>]")
+            self._dot_command_failed("usage: .break <file:line | keyword name> [, <condition>]")
             return
         spec, condition = arg, None
         if "," in arg:  # `.break <loc>, <condition>`
@@ -1863,7 +1868,6 @@ class ConsoleInterpreter(BaseInterpreter):
         assert controller is not None  # narrowed by _require_controller
         bps = controller.breakpoints
         for bp in bps:
-            loc = bp.name if bp.kind == "keyword" else f"{os.path.basename(bp.source or '?')}:{bp.line}"
             flags: List[str] = []
             if not bp.enabled:
                 flags.append("disabled")
@@ -1878,7 +1882,7 @@ class ConsoleInterpreter(BaseInterpreter):
             if bp.commands:
                 flags.append(f"{len(bp.commands)} {'cmd' if len(bp.commands) == 1 else 'cmds'}")
             suffix = ("  " + ", ".join(flags)) if flags else ""
-            self._echo(f"  #{bp.id}  {bp.kind:<7} {loc}{suffix}")
+            self._echo(f"  #{bp.id}  {bp.kind:<7} {bp.where}{suffix}")
         filters = controller.exception_filters
         if filters:
             self._echo(f"  catch    {', '.join(sorted(filters))}")
@@ -1892,11 +1896,11 @@ class ConsoleInterpreter(BaseInterpreter):
         try:
             bp_id = int(token)
         except (TypeError, ValueError):
-            self._echo(f"not a breakpoint number: {token}")
+            self._dot_command_failed(f"not a breakpoint number: {token}")
             return None
         bp = controller.get_breakpoint(bp_id)
         if bp is None:
-            self._echo(f"no breakpoint {bp_id}")
+            self._dot_command_failed(f"no breakpoint {bp_id}")
         return bp
 
     @dot_command("condition", group="Debugger")
@@ -1906,7 +1910,7 @@ class ConsoleInterpreter(BaseInterpreter):
             return
         parts = arg.split(None, 1)
         if not parts:
-            self._echo("usage: .condition <breakpoint-number> [<expression>]")
+            self._dot_command_failed("usage: .condition <breakpoint-number> [<expression>]")
             return
         bp = self._bp_by_arg(parts[0])
         if bp is None:
@@ -1924,7 +1928,7 @@ class ConsoleInterpreter(BaseInterpreter):
             return
         parts = arg.split()
         if len(parts) != 2:
-            self._echo("usage: .ignore <breakpoint-number> <count>")
+            self._dot_command_failed("usage: .ignore <breakpoint-number> <count>")
             return
         bp = self._bp_by_arg(parts[0])
         if bp is None:
@@ -1932,7 +1936,7 @@ class ConsoleInterpreter(BaseInterpreter):
         try:
             count = int(parts[1])
         except ValueError:
-            self._echo(f"not a count: {parts[1]}")
+            self._dot_command_failed(f"not a count: {parts[1]}")
             return
         bp.ignore_count = max(0, count)
         bp.hits = 0  # the next `count` triggering hits are skipped from now
@@ -1997,7 +2001,7 @@ class ConsoleInterpreter(BaseInterpreter):
         if not self._require_controller():
             return
         if not arg.strip():
-            self._echo("usage: .commands <breakpoint-number>")
+            self._dot_command_failed("usage: .commands <breakpoint-number>")
             return
         bp = self._bp_by_arg(arg.strip())
         if bp is None:
@@ -2045,7 +2049,7 @@ class ConsoleInterpreter(BaseInterpreter):
         for token in tokens:
             target = _CATCH_SHORTHANDS.get(token.lower())
             if target is None:
-                self._echo(f"unknown catch filter: {token}; try uncaught, all, test, suite, off")
+                self._dot_command_failed(f"unknown catch filter: {token}; try uncaught, all, test, suite, off")
                 return
             mapped.add(target)
         controller.set_exception_breakpoints(mapped)
@@ -2077,7 +2081,7 @@ class ConsoleInterpreter(BaseInterpreter):
             controller.set_attached(False)
             self._echo("debugger: detached")
         else:
-            self._echo("usage: .debug on|off")
+            self._dot_command_failed("usage: .debug on|off")
 
     @dot_command("detach", group="Debugger")
     def _detach(self, arg: str) -> None:
@@ -2099,13 +2103,21 @@ class ConsoleInterpreter(BaseInterpreter):
 
     @dot_command("abort", group="Debugger")
     def _abort(self, arg: str) -> None:
-        """Abort the run and exit. Use `.detach` to let the suite finish instead."""
+        """End the run: the current test fails, the rest don't run, teardowns run, the output is written.
+
+        Use `.detach` to let the suite finish instead.
+        """
         del arg
         if self._stop is None:
-            self._echo("no run to abort")
+            self._dot_command_failed("no run to abort")
             return
-        # Robot can't be cleanly stopped mid-keyword from a logger callback — a
-        # raised exception is swallowed by suite.run() — so exit via SystemExit,
-        # the one exception Robot does propagate.
         self._echo("aborting the run")
-        sys.exit(1)
+        self._pending_action = ResumeAction.CONTINUE
+        self.exit_code = 253
+        self._aborted = True
+        try:
+            # As SIGTERM does, so that Robot Framework writes the output files to their end.
+            STOP_SIGNAL_MONITOR(signal.SIGTERM, None)
+        except ExecutionStatus:
+            # For a keyword that runs: from here it would get lost, the next keyword that starts stops the run.
+            pass

robotcode_repl-2.9.0.dev87/src/robotcode/repl/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.9.0-dev.87"