Skip to content

πŸ’« Toolkit to help you get started with SDD or any other process!

fix(presets): escape installed preset metadata in Rich output (#3826)

Noor ul ainb048e339a524
diff --git a/src/specify_cli/presets/_commands.py b/src/specify_cli/presets/_commands.py
index ef4bf898d..437c8f3ff 100644
--- a/src/specify_cli/presets/_commands.py
+++ b/src/specify_cli/presets/_commands.py
@@ -59,8 +59,11 @@ def preset_list():
for pack in installed:
status = "[green]enabled[/green]" if pack.get("enabled", True) else "[red]disabled[/red]"
pri = pack.get('priority', 10)
- console.print(f" [bold]{pack['name']}[/bold] ({pack['id']}) v{pack['version']} β€” {status} β€” priority {pri}")
- console.print(f" {pack['description']}")
+ name = _escape_markup(str(pack['name']))
+ pack_id = _escape_markup(str(pack['id']))
+ version = _escape_markup(str(pack['version']))
+ console.print(f" [bold]{name}[/bold] ({pack_id}) v{version} β€” {status} β€” priority {pri}")
+ console.print(f" {_escape_markup(str(pack['description']))}")
tags = pack.get("tags", [])
if isinstance(tags, list) and tags:
tags_str = _escape_markup(", ".join(str(t) for t in tags))
@@ -317,13 +320,20 @@ def preset_resolve(
project_root = _require_specify_project()
resolver = PresetResolver(project_root)
layers = resolver.collect_all_layers(template_name)
+ safe_template_name = _escape_markup(str(template_name))
if layers:
# Use the highest-priority layer for display because the final output
# may be composed and may not map to resolve_with_source()'s single path.
display_layer = layers[0]
- console.print(f" [bold]{template_name}[/bold]: {display_layer['path']}")
- console.print(f" [dim](top layer from: {display_layer['source']})[/dim]")
+ console.print(
+ f" [bold]{safe_template_name}[/bold]: "
+ f"{_escape_markup(str(display_layer['path']))}"
+ )
+ console.print(
+ f" [dim](top layer from: "
+ f"{_escape_markup(str(display_layer['source']))})[/dim]"
+ )
has_composition = (
layers[0]["strategy"] != "replace"
@@ -335,7 +345,10 @@ def preset_resolve(
composed = resolver.resolve_content(template_name)
except Exception as exc:
composed = None
- console.print(f" [yellow]Warning: composition error: {exc}[/yellow]")
+ console.print(
+ f" [yellow]Warning: composition error: "
+ f"{_escape_markup(str(exc))}[/yellow]"
+ )
if composed is None:
console.print(" [yellow]Warning: composition cannot produce output (no base layer with 'replace' strategy)[/yellow]")
else:
@@ -358,15 +371,27 @@ def preset_resolve(
strategy_label = layer["strategy"]
if strategy_label == "replace" and i == 0:
strategy_label = "base"
- console.print(f" {i + 1}. [{strategy_label}] {layer['source']} β†’ {layer['path']}")
+ # Escape the literal bracket (\[) so Rich renders `[<strategy>]`
+ # instead of parsing it as a style tag and swallowing the label,
+ # mirroring `workflow info`'s step-graph line.
+ console.print(
+ f" {i + 1}. \\[{_escape_markup(str(strategy_label))}] "
+ f"{_escape_markup(str(layer['source']))} β†’ "
+ f"{_escape_markup(str(layer['path']))}"
+ )
else:
# No layers found β€” fall back to resolve_with_source for non-composition cases
result = resolver.resolve_with_source(template_name)
if result:
- console.print(f" [bold]{template_name}[/bold]: {result['path']}")
- console.print(f" [dim](from: {result['source']})[/dim]")
+ console.print(
+ f" [bold]{safe_template_name}[/bold]: "
+ f"{_escape_markup(str(result['path']))}"
+ )
+ console.print(
+ f" [dim](from: {_escape_markup(str(result['source']))})[/dim]"
+ )
else:
- console.print(f" [yellow]{template_name}[/yellow]: not found")
+ console.print(f" [yellow]{safe_template_name}[/yellow]: not found")
console.print(" [dim]No template with this name exists in the resolution stack[/dim]")
@@ -386,24 +411,32 @@ def preset_info(
local_pack = manager.get_pack(preset_id)
if local_pack:
- console.print(f"\n[bold cyan]Preset: {local_pack.name}[/bold cyan]\n")
- console.print(f" ID: {local_pack.id}")
- console.print(f" Version: {local_pack.version}")
- console.print(f" Description: {local_pack.description}")
+ console.print(
+ f"\n[bold cyan]Preset: {_escape_markup(str(local_pack.name))}[/bold cyan]\n"
+ )
+ console.print(f" ID: {_escape_markup(str(local_pack.id))}")
+ console.print(f" Version: {_escape_markup(str(local_pack.version))}")
+ console.print(
+ f" Description: {_escape_markup(str(local_pack.description))}"
+ )
if local_pack.author:
- console.print(f" Author: {local_pack.author}")
+ console.print(f" Author: {_escape_markup(str(local_pack.author))}")
local_tags = local_pack.tags
if isinstance(local_tags, list) and local_tags:
- console.print(f" Tags: {', '.join(str(t) for t in local_tags)}")
+ tags_str = _escape_markup(", ".join(str(t) for t in local_tags))
+ console.print(f" Tags: {tags_str}")
console.print(f" Templates: {len(local_pack.templates)}")
for tmpl in local_pack.templates:
- console.print(f" - {tmpl['name']} ({tmpl['type']}): {tmpl.get('description', '')}")
+ tmpl_name = _escape_markup(str(tmpl['name']))
+ tmpl_type = _escape_markup(str(tmpl['type']))
+ tmpl_desc = _escape_markup(str(tmpl.get('description', '')))
+ console.print(f" - {tmpl_name} ({tmpl_type}): {tmpl_desc}")
repo = local_pack.data.get("preset", {}).get("repository")
if repo:
- console.print(f" Repository: {repo}")
+ console.print(f" Repository: {_escape_markup(str(repo))}")
license_val = local_pack.data.get("preset", {}).get("license")
if license_val:
- console.print(f" License: {license_val}")
+ console.print(f" License: {_escape_markup(str(license_val))}")
console.print("\n [green]Status: installed[/green]")
# Get priority from registry
pack_metadata = manager.registry.get(preset_id)
@@ -438,7 +471,8 @@ def preset_info(
)
catalog_tags = pack_info.get("tags", [])
if isinstance(catalog_tags, list) and catalog_tags:
- console.print(f" Tags: {', '.join(str(t) for t in catalog_tags)}")
+ catalog_tags_str = _escape_markup(", ".join(str(t) for t in catalog_tags))
+ console.print(f" Tags: {catalog_tags_str}")
if pack_info.get("repository"):
console.print(
f" Repository: {_escape_markup(str(pack_info['repository']))}"
diff --git a/tests/test_presets.py b/tests/test_presets.py
index f4813eae1..60de97029 100644
--- a/tests/test_presets.py
+++ b/tests/test_presets.py
@@ -12209,3 +12209,213 @@ class TestPresetCatalogRichMarkup:
):
value = self.MARKUP_PRESET[field]
assert value in output
+ # Tags are joined into a single line, so assert on the rendered join.
+ assert ", ".join(self.MARKUP_PRESET["tags"]) in output
+
+
+class TestInstalledPresetRichMarkup:
+ """Locally installed preset metadata must render as literal text.
+
+ ``preset.yml`` is user-editable, so its fields can contain ``[...]``.
+ ``TestPresetCatalogRichMarkup`` covers the catalog branch of these
+ commands; the installed-preset branch of ``preset list``/``preset info``
+ and all of ``preset resolve`` were left unescaped, so a field like
+ ``Does [stuff] nicely`` silently rendered as ``Does nicely`` and an
+ unbalanced tag such as ``[/red]`` raised ``rich.errors.MarkupError``,
+ aborting the command with a traceback.
+ """
+
+ MARKUP_FIELDS = {
+ "name": "[green]Markup Name[/green]",
+ "version": "1.0.0",
+ "description": "[yellow]Markup Description[/yellow]",
+ "author": "[magenta]Markup Author[/magenta]",
+ "repository": "[bold]Markup Repository[/bold]",
+ "license": "[cyan]Markup License[/cyan]",
+ }
+
+ def _install(self, temp_dir, project_dir, preset_overrides=None, strategy=None,
+ pack_id="markup-pack", priority=10, tmpl_description=None):
+ """Install a preset from a directory built with the given manifest fields."""
+ from specify_cli.presets import PresetManager
+
+ src = temp_dir / f"src-{pack_id}"
+ (src / "templates").mkdir(parents=True)
+ (src / "templates" / "spec-template.md").write_text("# tmpl\n")
+
+ preset_section = {
+ "id": pack_id,
+ "name": pack_id,
+ "version": "1.0.0",
+ "description": "plain description",
+ }
+ preset_section.update(preset_overrides or {})
+ tmpl = {
+ "type": "template",
+ "name": "spec-template",
+ "file": "templates/spec-template.md",
+ }
+ if tmpl_description is not None:
+ tmpl["description"] = tmpl_description
+ if strategy:
+ tmpl["strategy"] = strategy
+ (src / "preset.yml").write_text(yaml.dump({
+ "schema_version": "1.0",
+ "preset": preset_section,
+ "requires": {"speckit_version": ">=0.0.1"},
+ "provides": {"templates": [tmpl]},
+ "tags": ["[italic]markup-tag[/italic]"],
+ }))
+
+ manager = PresetManager(project_dir)
+ manager.install_from_directory(src, "9.9.9", priority)
+ return manager
+
+ def _invoke(self, project_dir, args):
+ from typer.testing import CliRunner
+ from unittest.mock import patch
+ from specify_cli import app
+
+ with patch.object(Path, "cwd", return_value=project_dir):
+ return CliRunner().invoke(app, args)
+
+ def test_list_and_info_escape_installed_markup(self, temp_dir, project_dir):
+ """Every ``preset.yml`` field must survive verbatim in list/info output."""
+ self._install(temp_dir, project_dir, preset_overrides=self.MARKUP_FIELDS)
+
+ for args in (["preset", "list"], ["preset", "info", "markup-pack"]):
+ result = self._invoke(project_dir, args)
+ assert result.exit_code == 0, result.output
+ output = " ".join(strip_ansi(result.output).split())
+ # `preset list` does not render repository/license.
+ fields = ("name", "description") if args[1] == "list" else self.MARKUP_FIELDS
+ for field in fields:
+ assert self.MARKUP_FIELDS[field] in output, (field, args, output)
+ assert "[italic]markup-tag[/italic]" in output, (args, output)
+
+ def test_info_does_not_swallow_template_description(self, temp_dir, project_dir):
+ """The per-template line in ``preset info`` must escape the template description.
+
+ ``name``/``type`` are format-restricted by manifest validation, but
+ ``description`` is free-form, so it is the field that can carry markup.
+ """
+ self._install(
+ temp_dir,
+ project_dir,
+ tmpl_description="Template [desc] here",
+ )
+ result = self._invoke(project_dir, ["preset", "info", "markup-pack"])
+ assert result.exit_code == 0, result.output
+ output = " ".join(strip_ansi(result.output).split())
+ assert "spec-template (template): Template [desc] here" in output, output
+
+ def test_unbalanced_markup_does_not_crash_list_or_info(self, temp_dir, project_dir):
+ """An unbalanced tag must not raise MarkupError and abort the command."""
+ self._install(
+ temp_dir,
+ project_dir,
+ preset_overrides={"description": "Broken [/red] tag"},
+ )
+
+ for args in (["preset", "list"], ["preset", "info", "markup-pack"]):
+ result = self._invoke(project_dir, args)
+ assert result.exit_code == 0, (args, result.output, result.exception)
+ assert "Broken [/red] tag" in strip_ansi(result.output)
+
+ def test_resolve_escapes_template_name(self, project_dir):
+ """``preset resolve`` echoes its argument; an unbalanced tag must not crash."""
+ result = self._invoke(project_dir, ["preset", "resolve", "no[/red]such"])
+ assert result.exit_code == 0, (result.output, result.exception)
+ assert "no[/red]such" in strip_ansi(result.output)
+
+ def test_resolve_escapes_layer_path_and_source(self, project_dir):
+ """The top-layer path/source lines must render markup literally.
+
+ A preset can be installed from any directory, so the resolved path can
+ contain ``[...]``; the layer source carries the pack id and version.
+ """
+ from unittest.mock import patch
+ from specify_cli.presets import PresetResolver
+
+ # A closing tag cannot live inside a path segment: `Path` treats its
+ # `/` as a separator on POSIX and rewrites it to `\` on Windows. The
+ # opening tag covers the swallowing case for the path; the unbalanced
+ # closing tag rides on `source`, which is a plain string.
+ layer = {
+ "path": Path("/tmp/[red]dir/spec-template.md"),
+ "source": "pack [/red] v1.0.0",
+ "strategy": "replace",
+ }
+ with patch.object(PresetResolver, "collect_all_layers", return_value=[layer]):
+ result = self._invoke(project_dir, ["preset", "resolve", "spec-template"])
+
+ assert result.exit_code == 0, (result.output, result.exception)
+ output = " ".join(strip_ansi(result.output).split())
+ assert "[red]dir" in output, output
+ assert "pack [/red] v1.0.0" in output, output
+
+ def test_resolve_escapes_fallback_path_and_source(self, project_dir):
+ """The no-layer fallback branch must escape ``resolve_with_source`` output."""
+ from unittest.mock import patch
+ from specify_cli.presets import PresetResolver
+
+ with patch.object(
+ PresetResolver, "collect_all_layers", return_value=[]
+ ), patch.object(
+ PresetResolver,
+ "resolve_with_source",
+ return_value={
+ "path": "/tmp/[blue]fallback[/blue]/spec-template.md",
+ "source": "fallback [/red] source",
+ },
+ ):
+ result = self._invoke(project_dir, ["preset", "resolve", "spec-template"])
+
+ assert result.exit_code == 0, (result.output, result.exception)
+ output = " ".join(strip_ansi(result.output).split())
+ assert "[blue]fallback[/blue]" in output, output
+ assert "fallback [/red] source" in output, output
+
+ def test_resolve_escapes_composition_error(self, project_dir):
+ """A composition exception message must not be parsed as markup."""
+ from unittest.mock import patch
+ from specify_cli.presets import PresetResolver
+
+ layers = [
+ {
+ "path": Path("/tmp/top/spec-template.md"),
+ "source": "top-pack v1.0.0",
+ "strategy": "append",
+ },
+ {
+ "path": Path("/tmp/base/spec-template.md"),
+ "source": "base-pack v1.0.0",
+ "strategy": "append",
+ },
+ ]
+ with patch.object(
+ PresetResolver, "collect_all_layers", return_value=layers
+ ), patch.object(
+ PresetResolver,
+ "resolve_content",
+ side_effect=RuntimeError("compose failed: [/red] bad layer"),
+ ):
+ result = self._invoke(project_dir, ["preset", "resolve", "spec-template"])
+
+ assert result.exit_code == 0, (result.output, result.exception)
+ output = " ".join(strip_ansi(result.output).split())
+ assert "compose failed: [/red] bad layer" in output, output
+
+ def test_resolve_renders_composition_strategy_labels(self, temp_dir, project_dir):
+ """The composition chain's ``[<strategy>]`` label must not be eaten as a tag."""
+ self._install(temp_dir, project_dir, strategy="replace",
+ pack_id="base-pack", priority=20)
+ self._install(temp_dir, project_dir, strategy="append",
+ pack_id="app-pack", priority=5)
+
+ result = self._invoke(project_dir, ["preset", "resolve", "spec-template"])
+ assert result.exit_code == 0, (result.output, result.exception)
+ output = strip_ansi(result.output)
+ assert "Composition chain" in output, output
+ assert "[base]" in output, output
+ assert "[append]" in output, output