codeplain 0.3.11.dev11__tar.gz → 0.3.11.dev13__tar.gz

{codeplain-0.3.11.dev11 → codeplain-0.3.11.dev13}/.flake8

@@ -20,6 +20,8 @@ exclude =
 per-file-ignores =
     __init__.py: F401
     tests/*: U100
+# require_git() runs between imports in plain_modules.py, so the imports below it trip E402
+    plain_modules.py: E402
 max-complexity = 15
 enable-extensions = U100
 # Plugin-specific configuration

{codeplain-0.3.11.dev11 → codeplain-0.3.11.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.11.dev11
+Version: 0.3.11.dev13
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

codeplain-0.3.11.dev13/git_preflight.py

@@ -0,0 +1,41 @@
+"""Verify a working git is available before GitPython is imported.
+
+GitPython probes for the git executable on import and raises from module scope
+if it is missing or broken, so the CLI would crash with a traceback before
+main() could explain it.
+"""
+
+import shutil
+import subprocess
+import sys
+
+from plain2code_console import console
+
+GIT_MISSING_MESSAGE = "git is not installed. Please install git and try again."
+GIT_BROKEN_MESSAGE = "git is installed but not working. Please repair your git installation and try again."
+MACOS_BROKEN_GIT_HINT = (
+    "This usually means the Command Line Tools are missing; install them with 'xcode-select --install'."
+)
+
+
+def git_runs(git_path):
+    """Whether `git version` succeeds. A git on PATH can still be unusable: on
+    macOS without the Command Line Tools /usr/bin/git is a stub that exits with
+    an xcrun error, and GIT_PYTHON_REFRESH=quiet does not suppress that."""
+    try:
+        return subprocess.run([git_path, "version"], capture_output=True, timeout=10).returncode == 0
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
+def require_git():
+    """Exit with a clean message unless a working git is available."""
+    git_path = shutil.which("git")
+    if git_path is None:
+        console.error(f"{GIT_MISSING_MESSAGE}\n")
+        sys.exit(1)
+
+    if not git_runs(git_path):
+        hint = f"\n{MACOS_BROKEN_GIT_HINT}" if sys.platform == "darwin" else ""
+        console.error(f"{GIT_BROKEN_MESSAGE}{hint}\n")
+        sys.exit(1)

{codeplain-0.3.11.dev11 → codeplain-0.3.11.dev13}/plain_modules.py

@@ -6,18 +6,18 @@ import tempfile
 import zipfile
 from functools import cached_property
 
+from git_preflight import require_git
 from plain2code_exceptions import (
-    GitNotInstalledError,
     InvalidModuleArchiveError,
     MissingPreviousFunctionalitiesError,
     ModuleDoesNotExistError,
 )
 
-try:
-    from git import Repo
-    from git.exc import NoSuchPathError
-except ImportError:
-    raise GitNotInstalledError("git is not installed. Please install git and try again.")
+# Must run before GitPython is imported, which raises on a missing or broken git.
+require_git()
+
+from git import Repo
+from git.exc import NoSuchPathError
 
 import file_utils
 import git_utils

codeplain-0.3.11.dev13/tests/test_git_preflight.py

@@ -0,0 +1,98 @@
+"""Regression tests for issue #133.
+
+When git is unusable the CLI must report a clean message and exit 1, never dump
+a traceback. The failure is at import time (GitPython raises from module scope
+before main() runs), so the CLI is run in a subprocess and asserted on what a
+user would actually see. sys.executable is launched by absolute path, so
+replacing PATH only controls which git, if any, can be found.
+"""
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from git_preflight import GIT_BROKEN_MESSAGE, GIT_MISSING_MESSAGE
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+TRACEBACK_MARKER = "Traceback (most recent call last)"
+
+# The crash was in the import chain, so it hit every entry point equally.
+CLI_INVOCATIONS = [["--version"], ["--status"], ["does-not-exist.plain"]]
+
+
+def run_cli(args, path_dir=None):
+    """Run the CLI and return its exit code and output, stripped of styling and
+    with whitespace collapsed, so assertions survive console line wrapping."""
+    env = os.environ.copy()
+    # Drop GitPython overrides so the PATH search decides whether git is found.
+    env.pop("GIT_PYTHON_GIT_EXECUTABLE", None)
+    env.pop("GIT_PYTHON_REFRESH", None)
+    env.setdefault("CODEPLAIN_API_KEY", "dummy")
+    if path_dir is not None:
+        env["PATH"] = str(path_dir)
+
+    result = subprocess.run(
+        [sys.executable, "plain2code.py", *args],
+        cwd=REPO_ROOT,
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    output = re.sub(r"\x1b\[[0-9;]*m", "", result.stdout + result.stderr)
+    return result.returncode, " ".join(output.split())
+
+
+@pytest.fixture
+def no_git_dir(tmp_path):
+    """A directory containing no git at all, used as the whole PATH."""
+    d = tmp_path / "no-git"
+    d.mkdir()
+    return d
+
+
+@pytest.fixture
+def broken_git_dir(tmp_path):
+    """A directory whose git resolves but always fails, used as the whole PATH.
+    This is the shape of macOS without the Command Line Tools."""
+    d = tmp_path / "broken-git"
+    d.mkdir()
+    if sys.platform == "win32":
+        (d / "git.bat").write_text("@echo off\nexit /b 127\n")
+    else:
+        git = d / "git"
+        git.write_text("#!/bin/sh\nexit 127\n")
+        git.chmod(0o755)
+    return d
+
+
+@pytest.mark.parametrize("args", CLI_INVOCATIONS)
+def test_missing_git_reports_cleanly(args, no_git_dir):
+    rc, output = run_cli(args, no_git_dir)
+
+    assert GIT_MISSING_MESSAGE in output, output
+    assert TRACEBACK_MARKER not in output, output
+    # GitPython's own advice about GIT_PYTHON_REFRESH must not reach the user.
+    assert "GIT_PYTHON_REFRESH" not in output, output
+    assert rc == 1, output
+
+
+@pytest.mark.parametrize("args", CLI_INVOCATIONS)
+def test_broken_git_reports_cleanly(args, broken_git_dir):
+    rc, output = run_cli(args, broken_git_dir)
+
+    assert GIT_BROKEN_MESSAGE in output, output
+    assert GIT_MISSING_MESSAGE not in output, output
+    assert TRACEBACK_MARKER not in output, output
+    assert rc == 1, output
+
+
+def test_cli_works_when_git_is_present():
+    rc, output = run_cli(["--version"])
+
+    assert rc == 0, output
+    assert "codeplain version" in output, output

codeplain-0.3.11.dev13/tests/test_tui_components.py

@@ -0,0 +1,88 @@
+"""Regression tests: spec-derived text with square brackets must never be parsed as Textual markup."""
+
+import asyncio
+
+from textual.widgets import Static
+
+from event_bus import EventBus
+from plain2code_state import RunState
+from tui.components import ProgressItem, SubstateLine, TUIComponents
+from tui.models import Substate
+from tui.plain2code_tui import Plain2CodeTUI
+from tui.widget_helpers import display_error_message, display_success_message, update_progress_item_substates
+
+# Exact acceptance-test text that crashed the TUI with
+# "MarkupError: closing tag '[/#888888]' does not match any open tag":
+# the unterminated "[b" swallowed the timer's opening tag.
+UNTERMINATED_BRACKET_TEXT = (
+    "Rendering acceptance test: With a=1, b=2, c=3, d=4: ZRANK z c should reply 2, "
+    'ZREVRANK z c WITHSCORE should reply [1, "3"], ZRANK z zz should reply null, '
+    "ZCOUNT z (1 3 should reply 2, and ZLEXCOUNT z [b + should reply 3."
+)
+# Terminated brackets used to be silently eaten as a markup tag ("LPOP key ").
+TERMINATED_BRACKET_TEXT = "LPOP key [count] and RPOP key [count] reply one element"
+
+
+def _make_app(run_state: RunState, event_bus: EventBus) -> Plain2CodeTUI:
+    return Plain2CodeTUI(
+        event_bus=event_bus,
+        run_state=run_state,
+        on_ready=lambda: None,
+        render_id="test-render-id",
+        unittests_script=None,
+        conformance_tests_script="run_conformance_tests.sh",
+        prepare_environment_script=None,
+        state_machine_version="0.0.0",
+        css_path="styles.css",
+    )
+
+
+def test_substate_line_keeps_bracket_text_verbatim():
+    for text in (UNTERMINATED_BRACKET_TEXT, TERMINATED_BRACKET_TEXT):
+        line = SubstateLine(text, "    ", ProgressItem.PROCESSING)._format_line()
+        assert text in line.plain
+        assert line.plain.endswith("(0s)")
+        # Only the timer carries the muted style; the text itself is unstyled.
+        assert len(line.spans) == 1
+        assert line.plain[line.spans[0].start : line.spans[0].end] == "(0s)"
+
+
+def test_substate_with_brackets_renders_without_markup_error():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            widget_id = TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value
+            update_progress_item_substates(
+                app, widget_id, [Substate(UNTERMINATED_BRACKET_TEXT), Substate(TERMINATED_BRACKET_TEXT)]
+            )
+            await pilot.pause()
+            await pilot.pause()
+
+            lines = app.query(".substate-line-text").results(Static)
+            rendered = [str(line.content) for line in lines]
+            assert any(UNTERMINATED_BRACKET_TEXT in text for text in rendered)
+            assert any(TERMINATED_BRACKET_TEXT in text for text in rendered)
+
+    asyncio.run(scenario())
+
+
+def test_status_messages_keep_brackets():
+    async def scenario():
+        event_bus = EventBus()
+        run_state = RunState(spec_filename="x.plain")
+        app = _make_app(run_state, event_bus)
+        async with app.run_test() as pilot:
+            status = app.query_one(f"#{TUIComponents.RENDER_STATUS_WIDGET.value}", Static)
+
+            display_success_message(app, "out/[weird] path")
+            await pilot.pause()
+            assert "rendering completed!" in str(status.content)
+            assert "generated code folder: out/[weird] path" in str(status.content)
+
+            display_error_message(app, "Error: [Errno 2] No such file: run_tests.sh [b")
+            await pilot.pause()
+            assert "[Errno 2] No such file: run_tests.sh [b" in str(status.content)
+
+    asyncio.run(scenario())

{codeplain-0.3.11.dev11 → codeplain-0.3.11.dev13}/tui/components.py

@@ -3,6 +3,7 @@ from typing import Literal, Optional
 
 from rich.markup import escape
 from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.content import Content
 from textual.message import Message
 from textual.timer import Timer
 from textual.widgets import Button, Static
@@ -71,7 +72,7 @@ class CustomFooter(Horizontal):
         self._footer_text_widget = Static(footer_rendering_text, classes="custom-footer-text")
         yield self._footer_text_widget
         if self.render_id:
-            yield Static(f"render id: {self.render_id} ", classes="custom-footer-render-id")
+            yield Static(f"render id: {self.render_id} ", classes="custom-footer-render-id", markup=False)
 
     def update_footer_state(self, state: Literal["rendering", "pausing", "paused", "finished"]) -> None:
         self.remove_class("footer-state-default")
@@ -201,9 +202,12 @@ class SubstateLine(Horizontal):
     def _format_timer(self) -> str:
         return format_duration_hms(self._seconds_elapsed)
 
-    def _format_line(self) -> str:
+    def _format_line(self) -> Content:
+        # The substate text is arbitrary (acceptance-test text from the spec, module names, ...)
+        # and may contain square brackets, so it must never go through the markup parser.
+        # Build the line as Content and style only the timer part.
         timer = self._format_timer()
-        return f"{self.indent}  └ {self.text} [#888888]({timer})[/#888888]"
+        return Content.assemble(f"{self.indent}  └ {self.text} ", (f"({timer})", "#888888"))
 
     def _refresh_timer(self) -> None:
         try:
@@ -232,7 +236,7 @@ class ProgressItem(Vertical):
         # Main row with status and description
         with Horizontal(id=f"{self.id}-main-row", classes="progress-main-row"):
             yield Static(self._get_status_text(self.PENDING), classes=f"status {self.PENDING}")
-            yield Static(self.initial_text, classes="description")
+            yield Static(self.initial_text, classes="description", markup=False)
         # Substates container (full width, aligned to left)
         yield Vertical(id=f"{self.id}-substates", classes="substates-container")
 
@@ -367,8 +371,8 @@ class RenderingInfoBox(Vertical):
         self._refresh_content()
 
     def compose(self):
-        self.module_widget = Static(self.module_text, classes="rendering-info-row")
-        self.functionality_widget = Static(self.functionality_text, classes="rendering-info-row")
+        self.module_widget = Static(self.module_text, classes="rendering-info-row", markup=False)
+        self.functionality_widget = Static(self.functionality_text, classes="rendering-info-row", markup=False)
         yield Static("module status", classes="rendering-info-title")
         with Vertical(classes="rendering-info-box"):
             yield self.module_widget
@@ -430,9 +434,9 @@ class TestScriptsContainer(Vertical):
     def compose(self):
         yield Static("testing status", classes="test-scripts-title")
         with Vertical(classes="test-scripts-box"):
-            self.unit_widget = Static(self.unit_test_text, classes="test-script-row")
-            self.conformance_widget = Static(self.conformance_test_text, classes="test-script-row")
-            self.testing_widget = Static(self.testing_env_text, classes="test-script-row")
+            self.unit_widget = Static(self.unit_test_text, classes="test-script-row", markup=False)
+            self.conformance_widget = Static(self.conformance_test_text, classes="test-script-row", markup=False)
+            self.testing_widget = Static(self.testing_env_text, classes="test-script-row", markup=False)
             yield self.unit_widget
             yield self.conformance_widget
             yield self.testing_widget

{codeplain-0.3.11.dev11 → codeplain-0.3.11.dev13}/tui/widget_helpers.py

@@ -2,6 +2,7 @@
 
 from datetime import datetime
 
+from textual.content import Content
 from textual.css.query import NoMatches
 from textual.widgets import Static
 
@@ -89,9 +90,14 @@ def display_success_message(tui, rendered_code_path: str):
         rendered_code_path: The path to the rendered code
     """
 
-    message = (
-        f"[#79FC96]✓ rendering completed![/#79FC96] [#888888](press enter to exit)[/#888888]\n"
-        f"[#888888]generated code folder: {rendered_code_path}[/#888888] "
+    # rendered_code_path is user-controlled and may contain square brackets, so build the
+    # message as Content instead of interpolating it into a markup string.
+    message = Content.assemble(
+        ("✓ rendering completed!", "#79FC96"),
+        " ",
+        ("(press enter to exit)", "#888888"),
+        "\n",
+        (f"generated code folder: {rendered_code_path} ", "#888888"),
     )
 
     widget: Static = tui.query_one(f"#{TUIComponents.RENDER_STATUS_WIDGET.value}", Static)
@@ -120,7 +126,8 @@ def transition_frid_progress(tui, from_status: str | None, to_status: str):
 def display_error_message(tui, error_message: str):
     widget: Static = tui.query_one(f"#{TUIComponents.RENDER_STATUS_WIDGET.value}", Static)
     widget.add_class("error")
-    widget.update(error_message)
+    # Error text may contain square brackets (paths, tracebacks); keep it out of the markup parser.
+    widget.update(Content(error_message))
 
 
 def display_usage_summary(tui, functionalities: int, render_time_seconds: float) -> None: