robotcode-runner 2.8.0.dev677__tar.gz → 2.9.0.dev68__tar.gz

{robotcode_runner-2.8.0.dev677 → robotcode_runner-2.9.0.dev68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-runner
-Version: 2.8.0-dev.677
+Version: 2.9.0-dev.68
 Summary: RobotCode runner for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,13 +26,13 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: robotcode-modifiers==2.8.0-dev.677
-Requires-Dist: robotcode-plugin==2.8.0-dev.677
-Requires-Dist: robotcode-robot==2.8.0-dev.677
-Requires-Dist: robotcode==2.8.0-dev.677
+Requires-Dist: robotcode-modifiers==2.9.0-dev.68
+Requires-Dist: robotcode-plugin==2.9.0-dev.68
+Requires-Dist: robotcode-robot==2.9.0-dev.68
+Requires-Dist: robotcode==2.9.0-dev.68
 Requires-Dist: robotframework>=5.0.0
 Provides-Extra: html
-Requires-Dist: html-to-markdown>=2.0; extra == 'html'
+Requires-Dist: html-to-markdown>=3.18; extra == 'html'
 Description-Content-Type: text/markdown
 
 # robotcode-runner

{robotcode_runner-2.8.0.dev677 → robotcode_runner-2.9.0.dev68}/pyproject.toml

@@ -30,14 +30,14 @@ classifiers = [
 dynamic = ["version"]
 dependencies = [
   "robotframework>=5.0.0",
-  "robotcode-robot==2.8.0-dev.677",
-  "robotcode-modifiers==2.8.0-dev.677",
-  "robotcode-plugin==2.8.0-dev.677",
-  "robotcode==2.8.0-dev.677",
+  "robotcode-robot==2.9.0-dev.68",
+  "robotcode-modifiers==2.9.0-dev.68",
+  "robotcode-plugin==2.9.0-dev.68",
+  "robotcode==2.9.0-dev.68",
 ]
 
 [project.optional-dependencies]
-html = ["html-to-markdown>=2.0"]
+html = ["html-to-markdown>=3.18"]
 
 [project.entry-points.robotcode]
 runner = "robotcode.runner.hooks"

robotcode_runner-2.9.0.dev68/src/robotcode/runner/__version__.py

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

{robotcode_runner-2.8.0.dev677 → robotcode_runner-2.9.0.dev68}/src/robotcode/runner/cli/results/_html.py

@@ -1,15 +1,20 @@
 """HTML to Markdown conversion for Robot Framework log messages.
 
 Two-stage strategy:
-1. If `html-to-markdown` (optional dep) is installed, use it — better quality,
-   handles base64 image extraction natively.
+1. If `html-to-markdown` (optional dep) 3.18 or newer is installed, use it —
+   better quality, handles base64 image extraction natively. Older versions,
+   and versions that cannot be read, count as not installed: up to 3.17 the
+   converter drops everything after the `</td></tr><tr><td colspan="3">` that
+   SeleniumLibrary and Browser put in front of their screenshots, and up to
+   3.1 it also has another API.
 2. Otherwise fall back to a minimal stdlib `html.parser`-based converter for
    the small HTML subset Robot Framework actually emits (Selenium screenshots,
    bold/italic, links, lists, simple tables).
 
 In both paths, file-system references (relative `<img src="x.png">` or
-`<a href="x">`) are checked for path-traversal and resolved against `base_dir`,
-emitting absolute `file://` URLs for clickable terminal links (OSC 8).
+`<a href="x">`, and `file:` URLs) are resolved against `base_dir` and checked
+for path-traversal, emitting absolute `file://` URLs for clickable terminal
+links (OSC 8).
 
 Embedded data: URIs are recorded as ArtifactRefs (not extracted) unless the
 caller decides to extract via the artefact list afterwards.
@@ -22,25 +27,32 @@ import weakref
 from html.parser import HTMLParser
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
-from urllib.parse import unquote, urlparse
+from urllib.parse import unquote, urlparse, urlsplit
+from urllib.request import url2pathname
+
+from robotcode.core.utils.version import InvalidVersionError, create_version_from_str
 
 from ._models import ArtifactRef
 
 try:
     from html_to_markdown import ConversionOptions as _ExtOpts
+    from html_to_markdown import __version__ as _ext_version
     from html_to_markdown import convert as _ext_convert
 
-    _HAS_EXT = True
-except ImportError:
+    _ext_ver = create_version_from_str(_ext_version)
+    _HAS_EXT = (_ext_ver.major, _ext_ver.minor) >= (3, 18)
+except (ImportError, InvalidVersionError):
     _HAS_EXT = False
 
 
-# `bytes` can't be weakref'd, so wrap them.
+# `bytes` can't be weakref'd, so wrap them, together with the `download` name
+# of the link, which only matters for extraction.
 class _DataBox:
-    __slots__ = ("__weakref__", "data")
+    __slots__ = ("__weakref__", "data", "name")
 
-    def __init__(self, data: bytes) -> None:
+    def __init__(self, data: bytes, name: Optional[str]) -> None:
         self.data = data
+        self.name = name
 
 
 # Out-of-band store keeps decoded payloads off the serialisable dataclass and
@@ -48,8 +60,8 @@ class _DataBox:
 _EMBEDDED_DATA: "weakref.WeakKeyDictionary[ArtifactRef, _DataBox]" = weakref.WeakKeyDictionary()
 
 
-def _store_embedded_data(ref: ArtifactRef, data: bytes) -> None:
-    _EMBEDDED_DATA[ref] = _DataBox(data)
+def _store_embedded_data(ref: ArtifactRef, data: bytes, name: Optional[str]) -> None:
+    _EMBEDDED_DATA[ref] = _DataBox(data, name)
 
 
 def get_embedded_data(ref: ArtifactRef) -> Optional[bytes]:
@@ -62,6 +74,17 @@ def get_embedded_data(ref: ArtifactRef) -> Optional[bytes]:
     return box.data if box is not None else None
 
 
+def get_embedded_name(ref: ArtifactRef) -> Optional[str]:
+    """Return the `download` attribute of an embedded artefact's link, if any."""
+    box = _EMBEDDED_DATA.get(ref)
+    return box.name if box is not None else None
+
+
+def artefact_key(ref: ArtifactRef) -> Tuple[Any, ...]:
+    """Return the key by which references to the same target are merged."""
+    return (ref.resolved_path or ref.src, ref.embedded, ref.skipped_reason)
+
+
 def dedup_artefacts(refs: List[ArtifactRef]) -> List[ArtifactRef]:
     """Merge refs pointing to the same target.
 
@@ -73,7 +96,7 @@ def dedup_artefacts(refs: List[ArtifactRef]) -> List[ArtifactRef]:
     seen: Dict[Tuple[Any, ...], int] = {}
     out: List[ArtifactRef] = []
     for ref in refs:
-        key: Tuple[Any, ...] = (ref.resolved_path or ref.src, ref.embedded, ref.skipped_reason)
+        key = artefact_key(ref)
         idx = seen.get(key)
         if idx is None:
             seen[key] = len(out)
@@ -89,8 +112,20 @@ _DATA_URI_RE = re.compile(
     r"^data:(?P<mime>[^;,]+)?(?:;(?P<params>[^,]*))?,(?P<payload>.*)$",
     re.IGNORECASE | re.DOTALL,
 )
-_MD_IMG_RE = re.compile(r"!\[(?P<alt>[^\]]*)\]\((?P<src>[^)\s]+)(?:\s+\"[^\"]*\")?\)")
-_MD_LINK_RE = re.compile(r"(?<!\!)\[(?P<text>[^\]]+)\]\((?P<href>[^)\s]+)(?:\s+\"[^\"]*\")?\)")
+# A Markdown link target, in angle brackets (as html-to-markdown writes one with
+# a space) or up to the next space or `)`, and an optional title.
+_MD_DEST = r"(?:<[^>\n]*>|[^)\s]+)"
+# A backslash escape of CommonMark, which html-to-markdown writes for `\`, `<` and
+# `>` in a target in angle brackets.
+_MD_ESCAPE_RE = re.compile(r"\\([!-/:-@\[-`{-~])")
+_MD_TITLE = r'(?:\s+"[^"]*")?'
+_MD_IMG_RE = re.compile(rf"!\[(?P<alt>[^\]]*)\]\((?P<src>{_MD_DEST}){_MD_TITLE}\)")
+# Links, whose text may hold images, and stand-alone images in one pass, so that
+# every target is resolved once.
+_MD_REF_RE = re.compile(
+    rf"(?<!!)\[(?P<text>(?:!\[[^\]]*\]\({_MD_DEST}{_MD_TITLE}\)|[^\]])*)\]\((?P<href>{_MD_DEST}){_MD_TITLE}\)"
+    rf"|{_MD_IMG_RE.pattern}"
+)
 _TAG_STRIP_RE = re.compile(r"<[^>]+>")
 
 
@@ -146,47 +181,117 @@ def _is_external_url(href: str) -> bool:
     return bool(parsed.scheme) and parsed.scheme not in ("file",)
 
 
-def _resolve_under(base_dir: Path, src: str) -> tuple[Optional[Path], Optional[str]]:
-    """Return (resolved_path, skipped_reason). resolved_path is None if traversal."""
-    if not src or src.startswith(("#", "?")):
-        return None, "empty-or-fragment"
+def _md_url(url: str) -> str:
+    """Return `url` as a Markdown link destination, in angle brackets when it contains whitespace."""
+    return f"<{url}>" if any(c.isspace() for c in url) else url
+
+
+# OperatingSystem links a path on Windows as `file://C:\dir\x`, which puts the
+# drive into the host of the URL.
+_DRIVE_HOST_RE = re.compile(r"[A-Za-z]:")
+
+
+def _file_url_paths(href: str) -> Optional[Tuple[str, str]]:
+    """Return the path a `file:` URL names, decoded and as written, or None
+    when the URL names another host."""
+    parts = urlsplit(href)
+    drive_host = _DRIVE_HOST_RE.match(parts.netloc) is not None
+    if parts.netloc and not drive_host and parts.netloc.lower() != "localhost":
+        return None
+    raw = href[len("file:") :]
+    if raw.startswith("//"):
+        raw = raw[2:] if drive_host else raw[2 + len(parts.netloc) :]
+    if drive_host:
+        return unquote(parts.netloc + parts.path), raw
+    return url2pathname(parts.path), raw
+
+
+def _exists(path: Path) -> bool:
     try:
-        candidate = (base_dir / src).resolve()
-        base_resolved = base_dir.resolve()
-    except (OSError, RuntimeError):
-        return None, "resolve-failed"
+        return path.exists()
+    except (OSError, ValueError):
+        return False
+
+
+def _is_dir(path: Path) -> bool:
     try:
-        candidate.relative_to(base_resolved)
-    except ValueError:
-        return None, "path-traversal"
-    return candidate, None
+        return path.is_dir()
+    except (OSError, ValueError):
+        return False
+
+
+def _local_path(href: str, base_dir: Path) -> Optional[Tuple[Path, bool]]:
+    """Return the path a file-system reference names and whether it is a
+    `file:` URL, or None for a `file:` URL of another host.
+
+    Percent escapes are decoded and query and fragment dropped. OperatingSystem
+    links its paths without encoding them, so when the decoded path does not
+    exist but the reference as written does, that one is taken.
+    """
+    is_file_url = urlsplit(href).scheme == "file"
+    if is_file_url:
+        paths = _file_url_paths(href)
+        if paths is None:
+            return None
+        decoded, raw = paths
+    else:
+        decoded, raw = unquote(urlsplit(href).path), href
+    path = base_dir / decoded
+    if not _exists(path) and _exists(base_dir / raw):
+        path = base_dir / raw
+    return path, is_file_url
 
 
 def _make_external_artifact(
     href: str, kind: str, base_dir: Path, on_artifact: Callable[[ArtifactRef], None]
 ) -> Optional[str]:
-    """Handle a non-data href. Returns a markdown-safe URL (file:// or None) or the
-    original href for external URLs. Records an ArtifactRef when the href points
-    into the filesystem."""
+    """Handle a non-data href. Returns the URL for the message: the `file://`
+    URL of the referenced file, the href itself, or None when the reference
+    can't be followed. Records an ArtifactRef for a file under `base_dir` and
+    for a relative reference that leaves it.
+
+    A `file:` URL outside `base_dir` or of another host keeps its href and is
+    no artefact, and neither is a link to a folder."""
     if _is_external_url(href):
         return href
 
-    resolved, skipped = _resolve_under(base_dir, href)
     ref = ArtifactRef(kind=kind, src=href)
-    if resolved is None:
-        ref.skipped_reason = skipped
+    if not href or href.startswith(("#", "?")):
+        ref.skipped_reason = "empty-or-fragment"
         on_artifact(ref)
         return None
-    ref.resolved_path = str(resolved)
     try:
-        ref.rel_path = str(resolved.relative_to(base_dir.resolve()))
+        local = _local_path(href, base_dir)
+        if local is None:
+            return href
+        path, is_file_url = local
+        resolved = path.resolve()
+        base_resolved = base_dir.resolve()
+    except (OSError, RuntimeError, ValueError):
+        ref.skipped_reason = "resolve-failed"
+        on_artifact(ref)
+        return None
+    try:
+        rel: Optional[Path] = resolved.relative_to(base_resolved)
     except ValueError:
-        ref.rel_path = href
+        rel = None
+    if rel is None and is_file_url:
+        return href
+    if _is_dir(resolved):
+        return resolved.as_uri()
+    if rel is None:
+        ref.skipped_reason = "path-traversal"
+        on_artifact(ref)
+        return None
+    ref.resolved_path = str(resolved)
+    ref.rel_path = str(rel)
     on_artifact(ref)
     return resolved.as_uri()
 
 
-def _make_embedded_artifact(uri: str, kind: str, on_artifact: Callable[[ArtifactRef], None]) -> ArtifactRef:
+def _make_embedded_artifact(
+    uri: str, kind: str, on_artifact: Callable[[ArtifactRef], None], name: Optional[str] = None
+) -> ArtifactRef:
     ref = ArtifactRef(kind=kind, src=uri, embedded=True)
     parsed = _parse_data_uri(uri)
     if parsed is None:
@@ -196,7 +301,7 @@ def _make_embedded_artifact(uri: str, kind: str, on_artifact: Callable[[Artifact
     mime, data = parsed
     ref.media_type = mime
     ref.approx_bytes = len(data)
-    _store_embedded_data(ref, data)
+    _store_embedded_data(ref, data, name)
     on_artifact(ref)
     return ref
 
@@ -207,6 +312,27 @@ def _make_embedded_artifact(uri: str, kind: str, on_artifact: Callable[[Artifact
 
 if _HAS_EXT:
 
+    class _DownloadNames(HTMLParser):
+        """Collects the `download` attributes of `data:` links, which html-to-markdown drops."""
+
+        def __init__(self) -> None:
+            super().__init__(convert_charrefs=True)
+            self.names: Dict[str, str] = {}
+
+        def handle_starttag(self, tag: str, attrs: list[tuple[str, Optional[str]]]) -> None:
+            a = dict(attrs)
+            href, name = a.get("href"), a.get("download")
+            if tag == "a" and href and name and href.startswith("data:"):
+                self.names.setdefault(href, name)
+
+    def _download_names(text: str) -> Dict[str, str]:
+        if "download" not in text:
+            return {}
+        parser = _DownloadNames()
+        parser.feed(text)
+        parser.close()
+        return parser.names
+
     def _convert(
         text: str,
         *,
@@ -236,7 +362,13 @@ if _HAS_EXT:
                 embedded_urls.add(url)
                 _make_embedded_artifact(url, "image", on_artifact)
 
-        md = _post_process_refs(md, base_dir=base_dir, on_artifact=on_artifact, already_recorded=embedded_urls)
+        md = _post_process_refs(
+            md,
+            base_dir=base_dir,
+            on_artifact=on_artifact,
+            already_recorded=embedded_urls,
+            download_names=_download_names(text),
+        )
         return md.strip()
 
     def _post_process_refs(
@@ -245,14 +377,18 @@ if _HAS_EXT:
         base_dir: Path,
         on_artifact: Callable[[ArtifactRef], None],
         already_recorded: set[str],
+        download_names: Dict[str, str],
     ) -> str:
         """Replace relative file refs in markdown with absolute file:// URLs, and
         drop or annotate embedded data URIs in the rendered output (the binary
         payload is recorded via on_artifact instead)."""
 
+        def _target(dest: str) -> str:
+            return _MD_ESCAPE_RE.sub(r"\1", dest[1:-1]) if dest.startswith("<") else dest
+
         def _replace_img(m: re.Match[str]) -> str:
             alt = m.group("alt")
-            src = m.group("src")
+            src = _target(m.group("src"))
             if src.startswith("data:"):
                 if src not in already_recorded:
                     _make_embedded_artifact(src, "image", on_artifact)
@@ -261,23 +397,26 @@ if _HAS_EXT:
             if _is_external_url(src):
                 return m.group(0)
             new = _make_external_artifact(src, "image", base_dir, on_artifact)
-            return f"![{alt}]({new})" if new else f"_(missing image: {src})_"
+            return f"![{alt}]({_md_url(new)})" if new else f"_(missing image: {src})_"
 
-        def _replace_link(m: re.Match[str]) -> str:
-            text = m.group("text")
-            href = m.group("href")
+        def _replace_ref(m: re.Match[str]) -> str:
+            if m.group("href") is None:
+                return _replace_img(m)
+            text = _MD_IMG_RE.sub(_replace_img, m.group("text"))
+            href = _target(m.group("href"))
             if href.startswith("data:"):
                 if href not in already_recorded:
-                    _make_embedded_artifact(href, "file", on_artifact)
+                    _make_embedded_artifact(href, "file", on_artifact, download_names.get(href))
                     already_recorded.add(href)
-                return f"_(embedded {text or 'data'} — see artefacts)_"
+                # html-to-markdown writes the URI as the text of a link with only spaces in it.
+                return f"_(embedded {text if text and text != href else 'data'} — see artefacts)_"
             if _is_external_url(href):
-                return m.group(0)
+                # The target stays, the images in the text may have been replaced.
+                return f"[{text}]" + m.group(0)[len(m.group("text")) + 2 :]
             new = _make_external_artifact(href, "file", base_dir, on_artifact)
-            return f"[{text}]({new})" if new else f"_(missing link: {href})_"
+            return f"[{text}]({_md_url(new)})" if new else f"_(missing link: {href})_"
 
-        md = _MD_IMG_RE.sub(_replace_img, md)
-        return _MD_LINK_RE.sub(_replace_link, md)
+        return _MD_REF_RE.sub(_replace_ref, md)
 
 else:
     _INLINE_TAGS = {"b", "strong", "i", "em", "u", "code", "kbd", "samp", "var"}
@@ -298,7 +437,9 @@ else:
             self._list_kind: List[str] = []
             self._list_counter: List[int] = []
             self._in_pre = False
-            self._link_href: List[Optional[str]] = []
+            # Per open <a>: whether it embeds a file, its URL, and where its output starts.
+            self._links: List[Tuple[bool, Optional[str], int]] = []
+            self._media: List[str] = []
             self._row_cells: Optional[List[str]] = None
             self._table_rows: Optional[List[List[str]]] = None
             self._suppress_text = 0
@@ -360,13 +501,23 @@ else:
                 self._emit("#" * int(tag[1]) + " ")
             elif tag == "a":
                 href = a.get("href") or ""
-                url = self._handle_href(href, kind="file")
-                self._link_href.append(url)
-                self._emit("[")
+                if href.startswith("data:"):
+                    _make_embedded_artifact(href, "file", self._on_artifact, a.get("download"))
+                    self._links.append((True, None, len(self._out)))
+                    self._emit("_(embedded ")
+                else:
+                    self._links.append((False, self._handle_href(href, kind="file"), len(self._out)))
+                    self._emit("[")
             elif tag == "img":
                 src = a.get("src") or ""
                 alt = a.get("alt") or ""
                 self._handle_img(src, alt)
+            elif tag in ("video", "audio"):
+                self._media.append(tag)
+                self._handle_media(tag, a.get("src") or "")
+            elif tag == "source":
+                if self._media:
+                    self._handle_media(self._media[-1], a.get("src") or "")
             elif tag == "table":
                 self._table_rows = []
                 self._blank_line()
@@ -406,12 +557,17 @@ else:
             elif tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
                 self._blank_line()
             elif tag == "a":
-                href = self._link_href.pop() if self._link_href else None
-                self._emit("]")
-                if href:
-                    self._emit(f"({href})")
+                embedded, href, start = self._links.pop() if self._links else (False, None, 0)
+                if embedded:
+                    if not "".join(self._out[start + 1 :]).strip():
+                        self._emit("data")
+                    self._emit(" — see artefacts)_")
                 else:
-                    self._emit("()")
+                    self._emit("]")
+                    self._emit(f"({_md_url(href)})" if href else "()")
+            elif tag in ("video", "audio"):
+                if self._media:
+                    self._media.pop()
             elif tag in ("td", "th"):
                 if self._stack and self._stack[-1] == "cell":
                     self._stack.pop()
@@ -459,9 +615,6 @@ else:
         def _handle_href(self, href: str, *, kind: str) -> Optional[str]:
             if not href:
                 return None
-            if href.startswith("data:"):
-                _make_embedded_artifact(href, kind, self._on_artifact)
-                return None
             if _is_external_url(href):
                 return href
             return _make_external_artifact(href, kind, self._base_dir, self._on_artifact)
@@ -474,14 +627,25 @@ else:
                 self._emit(f"_(embedded image — see artefacts: {alt or 'no alt text'})_")
                 return
             if _is_external_url(src):
-                self._emit(f"![{alt}]({src})")
+                self._emit(f"![{alt}]({_md_url(src)})")
                 return
             url = _make_external_artifact(src, "image", self._base_dir, self._on_artifact)
             if url:
-                self._emit(f"![{alt}]({url})")
+                self._emit(f"![{alt}]({_md_url(url)})")
             else:
                 self._emit(f"_(missing image: {src})_")
 
+        def _handle_media(self, kind: str, src: str) -> None:
+            # A link with the element name as its text, as html-to-markdown shows <video> and <audio>.
+            if not src:
+                return
+            if src.startswith("data:"):
+                _make_embedded_artifact(src, "file", self._on_artifact)
+                self._emit(f"_(embedded {kind} — see artefacts)_")
+                return
+            url = self._handle_href(src, kind="file")
+            self._emit(f"[{kind}]({_md_url(url)})" if url else f"[{kind}]()")
+
     def _inline_open(tag: str) -> str:
         return {
             "b": "**",

{robotcode_runner-2.8.0.dev677 → robotcode_runner-2.9.0.dev68}/src/robotcode/runner/cli/results/results.py

@@ -2054,9 +2054,31 @@ def _make_message_entry(
     )
 
 
+def _safe_name(s: str) -> str:
+    return re.sub(r"[^\w.-]+", "_", s).strip("_")[:200]
+
+
 def _slugify(s: str) -> str:
-    slug = re.sub(r"[^\w.-]+", "_", s).strip("_")[:200]
-    return slug or "_test"
+    return _safe_name(s) or "_test"
+
+
+# Windows takes these names for devices, also with an extension.
+_WINDOWS_DEVICE_NAMES = frozenset(
+    ["CON", "PRN", "AUX", "NUL", *(f"COM{i}" for i in range(1, 10)), *(f"LPT{i}" for i in range(1, 10))]
+)
+
+
+def _download_file_name(download: Optional[str]) -> Optional[str]:
+    """Return the file name for an embedded file from the `download` attribute
+    of its link, made safe like test directory names, or None when it gives none."""
+    if not download:
+        return None
+    name = _safe_name(re.split(r"[/\\]", download)[-1])
+    if not name.strip("."):
+        return None
+    if name.split(".", 1)[0].upper() in _WINDOWS_DEVICE_NAMES:
+        name = f"_{name}"
+    return name
 
 
 def _extract_artifacts(tests: List[LogTest], *, target: Path) -> int:
@@ -2065,6 +2087,9 @@ def _extract_artifacts(tests: List[LogTest], *, target: Path) -> int:
     for t in tests:
         if not t.artifacts:
             continue
+        # The test keeps one reference per target, its messages their own ones; those get
+        # the result of the extraction too. The keys are taken before it changes them.
+        by_key = {_html.artefact_key(ref): ref for ref in t.artifacts}
         slug = _slugify(t.full_name)
         test_dir = (target / slug).resolve()
         try:
@@ -2072,6 +2097,7 @@ def _extract_artifacts(tests: List[LogTest], *, target: Path) -> int:
         except ValueError:
             for ref in t.artifacts:
                 ref.skipped_reason = ref.skipped_reason or "target-traversal"
+            _share_extraction(t.body, by_key)
             continue
         test_dir.mkdir(parents=True, exist_ok=True)
 
@@ -2085,9 +2111,11 @@ def _extract_artifacts(tests: List[LogTest], *, target: Path) -> int:
                 if data is None:
                     ref.skipped_reason = "no-data"
                     continue
-                ext = _html.ext_from_media_type(ref.media_type)
-                fname = _unique_name(f"embedded-{seq_embedded}{ext}", used_names)
-                seq_embedded += 1
+                name = _download_file_name(_html.get_embedded_name(ref))
+                if name is None:
+                    name = f"embedded-{seq_embedded}{_html.ext_from_media_type(ref.media_type)}"
+                    seq_embedded += 1
+                fname = _unique_name(name, used_names)
                 dest = (test_dir / fname).resolve()
                 try:
                     dest.relative_to(test_dir)
@@ -2112,9 +2140,22 @@ def _extract_artifacts(tests: List[LogTest], *, target: Path) -> int:
                 shutil.copy2(src_path, dest)
                 ref.extracted_to = str(dest)
                 count += 1
+        _share_extraction(t.body, by_key)
     return count
 
 
+def _share_extraction(entries: Optional[List[LogEntry]], by_key: Dict[Tuple[Any, ...], ArtifactRef]) -> None:
+    """Give every reference in `entries` the result of extracting the
+    test-level reference with the same key."""
+    for entry in entries or []:
+        for ref in entry.artifacts or []:
+            extracted = by_key.get(_html.artefact_key(ref))
+            if extracted is not None and extracted is not ref:
+                ref.extracted_to = extracted.extracted_to
+                ref.skipped_reason = extracted.skipped_reason
+        _share_extraction(entry.body, by_key)
+
+
 def _unique_name(name: str, used: Dict[str, int]) -> str:
     if name not in used:
         used[name] = 1

{robotcode_runner-2.8.0.dev677 → robotcode_runner-2.9.0.dev68}/src/robotcode/runner/cli/robot.py

@@ -1,7 +1,8 @@
 import os
 import weakref
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
 import click
 from robot.errors import DataError, Information
@@ -16,7 +17,7 @@ from robotcode.modifiers.metadata_modifiers import MetadataPattern
 from robotcode.plugin import Application, pass_application
 from robotcode.plugin.click_helper.aliases import AliasedCommand
 from robotcode.plugin.click_helper.types import add_options
-from robotcode.plugin.click_helper.wrappable import wrappable
+from robotcode.plugin.click_helper.wrappable import invoked_command_is_wrappable, run_under_wrapper, wrappable
 from robotcode.robot.config.loader import load_robot_config_from_path
 from robotcode.robot.config.model import RobotBaseProfile
 from robotcode.robot.config.utils import get_config_files
@@ -291,14 +292,36 @@ ROBOT_OPTIONS = [
 ]
 
 
-def handle_robot_options(
-    app: Application, robot_options_and_args: Tuple[str, ...]
-) -> Tuple[Optional[Path], RobotBaseProfile, List[str]]:
-    global _app
-    _app = app
+_LOADED_PROFILES = "robotcode.runner.loaded_profiles"
 
-    _patch()
+_Message = Union[str, Callable[[], Any]]
+
+
+@dataclass
+class LoadedRobotProfile:
+    """The configuration of a command, loaded once, with what loading it reported."""
+
+    root_folder: Optional[Path] = None
+    profile: Optional[RobotBaseProfile] = None
+    error: Optional[Exception] = None
+    messages: List[Tuple[Callable[[_Message], None], _Message]] = field(default_factory=list)
 
+    def show_messages(self) -> None:
+        messages, self.messages = self.messages, []
+        for show, message in messages:
+            show(message)
+
+
+def load_robot_profile(app: Application, robot_options_and_args: Tuple[str, ...]) -> LoadedRobotProfile:
+    """Load the configuration of a command once, from the paths among its arguments.
+
+    The result is kept for the whole command, with the messages and the error of the
+    loading, for later calls with the same paths, such as the one in `handle_robot_options`,
+    which shows them. A command that runs Robot Framework (`@wrappable`) is then started
+    again under its `wrapper`. Such a command calls this first, before it starts a server,
+    an interpreter or a debugger, so that they run under the `wrapper` too, while an error
+    of the configuration still appears where `handle_robot_options` raises it.
+    """
     robot_arguments: Optional[List[Union[str, Path]]] = None
 
     try:
@@ -307,21 +330,68 @@ def handle_robot_options(
     except (DataError, Information):
         pass
 
-    config_files, root_folder, _ = get_config_files(
-        robot_arguments,
-        app.config.config_files,
-        root_folder=app.config.root,
-        no_vcs=app.config.no_vcs,
-        verbose_callback=app.verbose,
+    ctx = click.get_current_context(silent=True)
+    loaded: Dict[Tuple[str, ...], LoadedRobotProfile] = (
+        ctx.find_root().meta.setdefault(_LOADED_PROFILES, {}) if ctx is not None else {}
     )
+    key = tuple(str(Path(a).absolute()) for a in robot_arguments or ())
+    if key in loaded:
+        return loaded[key]
+
+    result = LoadedRobotProfile()
+    loaded[key] = result
+
+    def verbose(message: _Message) -> None:
+        result.messages.append((app.verbose, message))
+
+    def error(message: _Message) -> None:
+        result.messages.append((app.error, message))
+
     try:
-        profile = (
-            load_robot_config_from_path(*config_files, verbose_callback=app.verbose)
-            .combine_profiles(*(app.config.profiles or []), verbose_callback=app.verbose, error_callback=app.error)
-            .evaluated_with_env(verbose_callback=app.verbose, error_callback=app.error)
+        config_files, result.root_folder, _ = get_config_files(
+            robot_arguments,
+            app.config.config_files,
+            root_folder=app.config.root,
+            no_vcs=app.config.no_vcs,
+            verbose_callback=verbose,
         )
-    except (TypeError, ValueError) as e:
-        raise click.ClickException(str(e)) from e
+        result.profile = (
+            load_robot_config_from_path(*config_files, verbose_callback=verbose)
+            .combine_profiles(*(app.config.profiles or []), verbose_callback=verbose, error_callback=error)
+            .evaluated_with_env(verbose_callback=verbose, error_callback=error)
+        )
+    except Exception as e:
+        result.error = e
+
+    if result.profile is not None and ctx is not None and invoked_command_is_wrappable(ctx):
+        try:
+            run_under_wrapper(app, result.profile.wrapper)
+        except click.ClickException:
+            # The wrapper did not start, so robotcode under it will not show them.
+            result.show_messages()
+            raise
+
+    return result
+
+
+def handle_robot_options(
+    app: Application, robot_options_and_args: Tuple[str, ...]
+) -> Tuple[Optional[Path], RobotBaseProfile, List[str]]:
+    global _app
+    _app = app
+
+    _patch()
+
+    loaded = load_robot_profile(app, robot_options_and_args)
+    loaded.show_messages()
+
+    if loaded.error is not None:
+        if isinstance(loaded.error, (TypeError, ValueError)):
+            raise click.ClickException(str(loaded.error)) from loaded.error
+        raise loaded.error
+
+    root_folder = loaded.root_folder
+    profile = cast(RobotBaseProfile, loaded.profile)
 
     cmd_options = profile.build_command_line()
 

robotcode_runner-2.8.0.dev677/src/robotcode/runner/__version__.py

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