robotcode-plugin 2.7.0__tar.gz → 2.8.0.dev8__tar.gz

{robotcode_plugin-2.7.0 → robotcode_plugin-2.8.0.dev8}/.gitignore

@@ -279,6 +279,9 @@ dist
 # vuepress build output
 .vuepress/dist
 
+# Astro (documentation site)
+docs/.astro/
+
 # Serverless directories
 .serverless/
 
@@ -339,7 +342,7 @@ bundled/libs
 # .agents
 .agents/
 skills-lock.json
-.claude
+#.claude
 
 # sarif files
 /**/*.sarif.json

{robotcode_plugin-2.7.0 → robotcode_plugin-2.8.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: robotcode-plugin
-Version: 2.7.0
+Version: 2.8.0-dev.8
 Summary: Some classes for RobotCode plugin management
 Project-URL: Donate, https://opencollective.com/robotcode
 Project-URL: Documentation, https://github.com/robotcodedev/robotcode#readme
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities

{robotcode_plugin-2.7.0 → robotcode_plugin-2.8.0.dev8}/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
   "Operating System :: OS Independent",

{robotcode_plugin-2.7.0 → robotcode_plugin-2.8.0.dev8}/src/robotcode/plugin/__init__.py

@@ -83,6 +83,8 @@ class CommonConfig:
     colored_output: ColoredOutput = ColoredOutput.AUTO
     default_paths: Optional[Sequence[str]] = None
     launcher_script: Optional[str] = None
+    wrapper: Optional[str] = None
+    no_wrapper: bool = False
     output_format: Optional[OutputFormat] = None
     pager: Optional[bool] = None
     log_enabled: bool = False
@@ -136,6 +138,7 @@ def _get_deep_markdown_cls() -> "type[Markdown]":
         TableHeaderElement,
         TableRowElement,
     )
+    from rich.segment import Segment
     from rich.text import Text
 
     class LeftHeading(Heading):
@@ -196,6 +199,25 @@ def _get_deep_markdown_cls() -> "type[Markdown]":
             parser.options.maxNesting = 1000
             self.parsed = parser.parse(markup)
 
+        def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+            # rich pads every line with spaces to the full console width. A
+            # pager that reserves columns (bat's line numbers and grid) wraps
+            # those full-width lines, and every wrapped remainder shows up
+            # as an empty line. Drop the padding unless it carries a
+            # background colour (code blocks draw a box with it).
+            for line in Segment.split_lines(cast(Iterable[Segment], super().__rich_console__(console, options))):
+                while line and not line[-1].control:
+                    text, style, _ = line[-1]
+                    if style is not None and style.bgcolor is not None:
+                        break
+                    text = text.rstrip(" ")
+                    if text:
+                        line[-1] = Segment(text, style)
+                        break
+                    line.pop()
+                yield from line
+                yield Segment.line()
+
     _deep_markdown_cls = DeepMarkdown
     return DeepMarkdown
 
@@ -341,7 +363,7 @@ class Application:
                 if dataclasses.is_dataclass(data)
                 else data
                 if isinstance(data, dict)
-                else {data: data}
+                else {"data": data}
             )
 
         if text is None:

robotcode_plugin-2.8.0.dev8/src/robotcode/plugin/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.8.0-dev.8"

robotcode_plugin-2.8.0.dev8/src/robotcode/plugin/click_helper/exit_codes.py

@@ -0,0 +1,21 @@
+import click
+
+_ROBOT_EXIT_CODES_ATTR = "__robotcode_robot_exit_codes__"
+
+
+def robot_exit_codes(cmd: click.Command) -> click.Command:
+    """Mark a CLI command that passes on the exit code of a Robot Framework tool.
+
+    Such a command answers with Robot Framework's exit codes, like the `wrappable`
+    commands that run Robot Framework, so an error robotcode reports itself for it
+    exits with Robot Framework's 252 instead of Click's 1 or 2. Mark the commands
+    that pass on a tool's exit code without running tests - rebot, libdoc,
+    testdoc; `wrappable` commands are covered already.
+    """
+    setattr(cmd, _ROBOT_EXIT_CODES_ATTR, True)
+    return cmd
+
+
+def has_robot_exit_codes(cmd: click.Command) -> bool:
+    """Return whether `cmd` was marked with :func:`robot_exit_codes`."""
+    return bool(getattr(cmd, _ROBOT_EXIT_CODES_ATTR, False))

robotcode_plugin-2.8.0.dev8/src/robotcode/plugin/click_helper/wrappable.py

@@ -0,0 +1,110 @@
+import os
+import shlex
+import subprocess
+import sys
+from typing import TYPE_CHECKING, Any, Optional, Sequence
+
+import click
+
+if TYPE_CHECKING:
+    from robotcode.plugin import Application
+
+# Set in the environment once a wrapper has been applied to the process tree.
+# Prevents infinite re-exec recursion and lets an outer layer (e.g. the VS Code
+# debug launcher applying its own wrapper) suppress the CLI/profile re-exec.
+WRAPPER_APPLIED_ENV = "ROBOTCODE_WRAPPER_APPLIED"
+
+_WRAPPABLE_ATTR = "__robotcode_wrappable__"
+
+
+def wrappable(cmd: click.Command) -> click.Command:
+    """Mark a CLI command as *wrappable*.
+
+    When a `wrapper` (session) command is configured, a wrappable command is
+    re-executed through it, because it executes Robot Framework (and may, for
+    example, need to run inside a specific X11/Wayland session). Commands that
+    do not execute Robot Framework - language server, discovery, libdoc, … -
+    must NOT be marked.
+
+    The re-execution happens when the command loads its configuration with
+    `load_robot_profile` or `handle_robot_options` of `robotcode.runner.cli.robot`,
+    so a marked command must do that first, before it starts a server, an
+    interpreter or a debugger. A marked command that loads its configuration in
+    another way runs without the wrapper.
+    """
+    setattr(cmd, _WRAPPABLE_ATTR, True)
+    return cmd
+
+
+def is_wrappable(cmd: click.Command) -> bool:
+    """Return whether `cmd` was marked with :func:`wrappable`."""
+    return bool(getattr(cmd, _WRAPPABLE_ATTR, False))
+
+
+def invoked_command_is_wrappable(ctx: click.Context) -> bool:
+    """Return whether the command that the root group invokes is marked with :func:`wrappable`.
+
+    A command that such a command runs itself, such as `robot` in `debug`, belongs to it.
+    """
+    root = ctx.find_root()
+    sub_name = root.invoked_subcommand
+    if not sub_name or not isinstance(root.command, click.Group):
+        return False
+    # Aliases resolve to the same command object, so this is alias-safe and needs
+    # no central name list.
+    sub_cmd = root.command.get_command(root, sub_name)
+    return sub_cmd is not None and is_wrappable(sub_cmd)
+
+
+def run_under_wrapper(app: "Application", profile_wrapper: Optional[Sequence[Any]]) -> None:
+    """Re-execute this process through the configured ``wrapper`` command.
+
+    A wrappable command calls this once it has loaded its configuration, before it
+    starts anything. ``--wrapper`` overrides the ``wrapper`` of the profile
+    (``profile_wrapper``); ``--no-wrapper`` disables wrapping for this run. The
+    guard env var prevents infinite recursion and lets an outer layer suppress the
+    re-exec by setting it itself. Returns when no wrapper applies or for a dry run.
+    """
+    if app.config.no_wrapper or os.environ.get(WRAPPER_APPLIED_ENV):
+        return
+
+    # `--wrapper` overrides the profile's `wrapper`. The evaluated profile turns
+    # StringExpression entries into plain strings.
+    if app.config.wrapper:
+        wrapper = shlex.split(app.config.wrapper)
+    elif profile_wrapper:
+        wrapper = [str(w) for w in profile_wrapper]
+    else:
+        return
+
+    # A dry run must not start the wrapper: it would set up and tear down the
+    # real environment. Show it instead; the command itself then prints its own
+    # dry-run output.
+    if app.config.dry:
+        app.echo(f"Dry run, not executing the wrapper. Would run robotcode under: {' '.join(wrapper)}")
+        return
+
+    # Rebuild the invocation the way this process was actually started, so the
+    # re-exec finds robotcode even when it runs from a bundled path (VS Code) and
+    # is not installed in the interpreter. `launcher_script` is set only when we
+    # were started through a bundled entry (its `__main__` sets it) or an explicit
+    # `--launcher-script`; otherwise robotcode is importable directly and
+    # `-m robotcode.cli` is correct. We deliberately do NOT consult the
+    # ROBOTCODE_BUNDLED_ROBOTCODE_MAIN env var: VS Code sets it in every terminal,
+    # so a directly started robotcode would be diverted to the bundled copy.
+    # Mirrors the debug launcher's `debugger_script` handling.
+    entry = [str(app.config.launcher_script)] if app.config.launcher_script else ["-m", "robotcode.cli"]
+    command = [*wrapper, sys.executable, *entry, *sys.argv[1:]]
+    app.verbose(lambda: "Running under wrapper: " + " ".join(command))
+
+    # Run robotcode again under the wrapper; the guard env stops the spawned
+    # robotcode from wrapping a second time. On POSIX we replace this process with
+    # execvp (no extra process); Windows has no such exec, so there we spawn the
+    # command, wait, and forward its exit code.
+    os.environ[WRAPPER_APPLIED_ENV] = "1"
+    try:
+        if sys.platform == "win32":
+            sys.exit(subprocess.run(command).returncode)
+        os.execvp(command[0], command)
+    except OSError as e:
+        raise click.ClickException(f"Failed to execute wrapper command {wrapper!r}: {e}") from e

robotcode_plugin-2.7.0/src/robotcode/plugin/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.7.0"

robotcode_plugin-2.7.0/src/robotcode/plugin/click_helper/wrappable.py

@@ -1,26 +0,0 @@
-import click
-
-# Set in the environment once a wrapper has been applied to the process tree.
-# Prevents infinite re-exec recursion and lets an outer layer (e.g. the VS Code
-# debug launcher applying its own wrapper) suppress the CLI/profile re-exec.
-WRAPPER_APPLIED_ENV = "ROBOTCODE_WRAPPER_APPLIED"
-
-_WRAPPABLE_ATTR = "__robotcode_wrappable__"
-
-
-def wrappable(cmd: click.Command) -> click.Command:
-    """Mark a CLI command as *wrappable*.
-
-    When a `wrapper` (session) command is configured, a wrappable command is
-    re-executed through it, because it executes Robot Framework (and may, for
-    example, need to run inside a specific X11/Wayland session). Commands that
-    do not execute Robot Framework - language server, discovery, libdoc, … -
-    must NOT be marked.
-    """
-    setattr(cmd, _WRAPPABLE_ATTR, True)
-    return cmd
-
-
-def is_wrappable(cmd: click.Command) -> bool:
-    """Return whether `cmd` was marked with :func:`wrappable`."""
-    return bool(getattr(cmd, _WRAPPABLE_ATTR, False))