codeplain 0.3.11.dev10__tar.gz → 0.3.11.dev12__tar.gz

{codeplain-0.3.11.dev10 → codeplain-0.3.11.dev12}/PKG-INFO

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

{codeplain-0.3.11.dev10 → codeplain-0.3.11.dev12}/codeplain_REST_api.py

@@ -237,6 +237,7 @@ class CodeplainAPI:
         required_modules,
         unittests_issue,
         run_state: RunState,
+        conformance_tests_fixes: list[dict] | None = None,
     ):
         endpoint_url = f"{self.api_url}/fix_unittests_issue"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
@@ -251,6 +252,10 @@ class CodeplainAPI:
             "unittests_issue": unittests_issue,
             "unittest_batch_id": run_state.unittest_batch_id,
         }
+        # Implementation code changes made by the conformance tests fixer right before this unit tests run;
+        # only sent when unit tests are processed inside the conformance tests phase.
+        if conformance_tests_fixes is not None:
+            payload["conformance_tests_fixes"] = conformance_tests_fixes
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 

{codeplain-0.3.11.dev10 → codeplain-0.3.11.dev12}/render_machine/actions/fix_conformance_test.py

@@ -189,6 +189,17 @@ class FixConformanceTest(BaseAction):
                 ctx.test_that_triggered_code_change = (ctx.current_testing_module_name, ctx.current_testing_frid)
                 ctx.execution_phase = TestExecutionPhase.RETRYING_AFTER_CODE_CHANGE
 
+                # Remember the change so that the unit tests fixer (which runs next) preserves it instead of
+                # reverting it - see FixUnitTests.
+                summary = fix_attempt_summary if isinstance(fix_attempt_summary, dict) else {}
+                ctx.implementation_code_fixes.append(
+                    {
+                        "hypothesis": summary.get("hypothesis"),
+                        "approach": summary.get("approach"),
+                        "code_diff": code_diff_files_content,
+                    }
+                )
+
                 journal.record_fix(
                     ctx.current_testing_module_name,
                     ctx.current_testing_frid,

{codeplain-0.3.11.dev10 → codeplain-0.3.11.dev12}/render_machine/actions/fix_unit_tests.py

@@ -32,6 +32,13 @@ class FixUnitTests(BaseAction):
 
         render_utils.print_inputs(render_context, existing_files_content, "Files sent as input to unit tests fixing:")
 
+        conformance_tests_fixes = self._get_conformance_tests_fixes(render_context)
+        if conformance_tests_fixes:
+            console.info(
+                f"Unit tests are fixed while preserving {len(conformance_tests_fixes)} implementation code change(s) "
+                "made to fix the conformance tests."
+            )
+
         response_files = render_context.codeplain_api.fix_unittests_issue(
             render_context.frid_context.frid,
             render_context.plain_source_tree,
@@ -41,6 +48,7 @@ class FixUnitTests(BaseAction):
             render_context.get_required_modules_functionalities(),
             previous_unittests_issue,
             run_state=render_context.run_state,
+            conformance_tests_fixes=conformance_tests_fixes,
         )
 
         _, changed_files = file_utils.update_build_folder_with_rendered_files(
@@ -52,3 +60,20 @@ class FixUnitTests(BaseAction):
         console.print_files("Files fixed:", render_context.build_folder, response_files, style=console.OUTPUT_STYLE)
 
         return self.SUCCESSFUL_OUTCOME, None
+
+    @staticmethod
+    def _get_conformance_tests_fixes(render_context: RenderContext) -> list[dict] | None:
+        """Implementation code changes the conformance tests fixer made before these unit tests were run.
+
+        Only present when unit tests are processed inside the conformance tests phase - the implementation
+        and refactoring unit test passes have no conformance tests running context.
+        """
+        conformance_tests_running_context = getattr(render_context, "conformance_tests_running_context", None)
+        if conformance_tests_running_context is None:
+            return None
+
+        implementation_code_fixes = getattr(conformance_tests_running_context, "implementation_code_fixes", None)
+        if not implementation_code_fixes:
+            return None
+
+        return list(implementation_code_fixes)

{codeplain-0.3.11.dev10 → codeplain-0.3.11.dev12}/render_machine/render_types.py

@@ -91,6 +91,11 @@ class ConformanceTestsRunningContext:
 
         self.current_testing_frid_high_level_implementation_plan: Optional[str] = None
 
+        # Implementation code changes made by the conformance tests fixer during this conformance phase, in
+        # order. Each entry is {"hypothesis": str | None, "approach": str | None, "code_diff": {file: diff}}.
+        # Handed to the unit tests fixer so it adjusts the unit tests instead of reverting these changes.
+        self.implementation_code_fixes: list[dict] = []
+
     def get_conformance_tests_json(self, module_name: str) -> dict:
         return self._conformance_tests_json[module_name]
 

codeplain-0.3.11.dev12/tests/test_fix_unit_tests_conformance_context.py

@@ -0,0 +1,230 @@
+"""Tests for handing the conformance tests fixer's implementation changes to the unit tests fixer.
+
+When the conformance tests fixer changes implementation code, the unit tests are re-run and fixed next.
+The unit tests fixer must know about that change so it adjusts the unit tests instead of reverting it.
+"""
+
+import os
+import tempfile
+from types import SimpleNamespace
+
+import pytest
+
+import plain_spec
+from memory_management import MemoryManager
+from render_machine.actions import fix_unit_tests as fix_unit_tests_module
+from render_machine.actions.fix_conformance_test import FixConformanceTest
+from render_machine.actions.fix_unit_tests import FixUnitTests
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
+from render_machine.render_types import ConformanceTestsRunningContext, UnitTestsRunningContext
+
+
+class FakeCodeplainAPI:
+    def __init__(self, conformance_fix_response=None, unittests_fix_response=None):
+        self.conformance_fix_response = conformance_fix_response
+        self.unittests_fix_response = unittests_fix_response or {}
+        self.unittests_fix_calls = []
+
+    def fix_conformance_tests_issue(self, *args, **kwargs):
+        return self.conformance_fix_response
+
+    def fix_unittests_issue(self, *args, **kwargs):
+        self.unittests_fix_calls.append(kwargs)
+        return self.unittests_fix_response
+
+
+class FakeConformanceTests:
+    def fetch_existing_conformance_test_files(self, *args):
+        return {}, {}
+
+    def store_conformance_tests_files(self, *args):
+        pass
+
+
+@pytest.fixture
+def build_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        with open(os.path.join(folder, "app.py"), "w", encoding="utf-8") as source_file:
+            source_file.write("def add(a, b):\n    return a + b\n")
+        yield folder
+
+
+@pytest.fixture
+def memory_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        yield folder
+
+
+@pytest.fixture(autouse=True)
+def isolate_from_git_and_console(monkeypatch):
+    monkeypatch.setattr(ImplementationCodeHelpers, "get_code_diff", staticmethod(lambda *args: {}))
+    monkeypatch.setattr(plain_spec, "collect_linked_resources", lambda *args: None)
+    monkeypatch.setattr(fix_unit_tests_module.render_utils, "print_inputs", lambda *args: None)
+
+
+def make_conformance_context():
+    return ConformanceTestsRunningContext(
+        current_testing_module_name="mod",
+        current_testing_frid="1",
+        fix_attempts=0,
+        conformance_tests_json={"1": {"folder_name": "conformance_1"}},
+        conformance_tests_render_attempts=0,
+        current_testing_frid_specifications={},
+        should_prepare_testing_environment=False,
+        frid_being_implemented="1",
+    )
+
+
+def make_render_context(api, build_folder, memory_folder, conformance_tests_running_context):
+    return SimpleNamespace(
+        codeplain_api=api,
+        build_folder=build_folder,
+        memory_manager=MemoryManager(api, memory_folder),
+        conformance_tests=FakeConformanceTests(),
+        conformance_tests_running_context=conformance_tests_running_context,
+        unit_tests_running_context=UnitTestsRunningContext(fix_attempts=1),
+        plain_source_tree={},
+        module_name="mod",
+        required_modules=None,
+        frid_context=SimpleNamespace(frid="1", linked_resources={}),
+        get_required_modules_functionalities=lambda: {},
+        run_state=SimpleNamespace(render_id="test-render-id", unittest_batch_id=1),
+    )
+
+
+def run_conformance_fix(render_context):
+    return FixConformanceTest().execute(render_context, {"previous_conformance_tests_issue": "tests failed"})
+
+
+def test_conformance_fix_of_implementation_code_is_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+            {"app.py": "def add(a, b):\n    return a + b + 1\n"},
+            {"hypothesis": "off by one", "approach": "add one"},
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_conformance_fix(render_context)
+
+    assert outcome == FixConformanceTest.IMPLEMENTATION_CODE_UPDATED
+    assert len(ctx.implementation_code_fixes) == 1
+    recorded_fix = ctx.implementation_code_fixes[0]
+    assert recorded_fix["hypothesis"] == "off by one"
+    assert recorded_fix["approach"] == "add one"
+    assert list(recorded_fix["code_diff"]) == ["app.py"]
+    assert "+    return a + b + 1" in recorded_fix["code_diff"]["app.py"]
+
+
+def test_consecutive_implementation_fixes_accumulate(build_folder, memory_folder):
+    ctx = make_conformance_context()
+    for attempt in range(2):
+        api = FakeCodeplainAPI(
+            conformance_fix_response=[
+                FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+                {"app.py": f"def add(a, b):\n    return a + b + {attempt + 1}\n"},
+                {"hypothesis": f"hypothesis {attempt}", "approach": f"approach {attempt}"},
+                "prepared issue",
+            ]
+        )
+        render_context = make_render_context(api, build_folder, memory_folder, ctx)
+        run_conformance_fix(render_context)
+
+    assert [fix["hypothesis"] for fix in ctx.implementation_code_fixes] == ["hypothesis 0", "hypothesis 1"]
+
+
+def test_conformance_fix_without_summary_is_still_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+            {"app.py": "def add(a, b):\n    return a + b + 1\n"},
+            None,
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    run_conformance_fix(render_context)
+
+    assert ctx.implementation_code_fixes[0]["hypothesis"] is None
+    assert ctx.implementation_code_fixes[0]["approach"] is None
+    assert "app.py" in ctx.implementation_code_fixes[0]["code_diff"]
+
+
+def test_conformance_fix_of_conformance_tests_is_not_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_CONFORMANCE_TESTS,
+            {"test_app.py": "def test_add(): pass\n"},
+            {"hypothesis": "wrong assertion", "approach": "fix test"},
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_conformance_fix(render_context)
+
+    assert outcome == FixConformanceTest.IMPLEMENTATION_CODE_NOT_UPDATED
+    assert ctx.implementation_code_fixes == []
+
+
+def test_implementation_fix_with_no_files_is_not_remembered(build_folder, memory_folder):
+    api = FakeCodeplainAPI(
+        conformance_fix_response=[
+            FixConformanceTest.ISSUE_REASON_CODE_IMPLEMENTATION_CODE,
+            {},
+            {"hypothesis": "nothing", "approach": "nothing"},
+            "prepared issue",
+        ]
+    )
+    ctx = make_conformance_context()
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_conformance_fix(render_context)
+
+    assert outcome == FixConformanceTest.IMPLEMENTATION_CODE_NOT_UPDATED
+    assert ctx.implementation_code_fixes == []
+
+
+def run_unit_tests_fix(render_context):
+    return FixUnitTests().execute(render_context, {"previous_unittests_issue": "1 failed"})
+
+
+def test_unit_tests_fix_forwards_conformance_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI(unittests_fix_response={"test_app.py": "def test_add(): pass\n"})
+    ctx = make_conformance_context()
+    ctx.implementation_code_fixes.append(
+        {"hypothesis": "off by one", "approach": "add one", "code_diff": {"app.py": "+    return a + b + 1"}}
+    )
+    render_context = make_render_context(api, build_folder, memory_folder, ctx)
+
+    outcome, _ = run_unit_tests_fix(render_context)
+
+    assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
+    assert len(api.unittests_fix_calls) == 1
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] == ctx.implementation_code_fixes
+    # The forwarded list is a copy, so later conformance fixes do not mutate what was sent.
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is not ctx.implementation_code_fixes
+
+
+def test_unit_tests_fix_outside_conformance_phase_sends_no_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, build_folder, memory_folder, None)
+
+    run_unit_tests_fix(render_context)
+
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None
+
+
+def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_sends_no_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, build_folder, memory_folder, make_conformance_context())
+
+    run_unit_tests_fix(render_context)
+
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None

codeplain-0.3.11.dev12/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.dev10 → codeplain-0.3.11.dev12}/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.dev10 → codeplain-0.3.11.dev12}/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: