codeplain 0.3.12.dev24__tar.gz → 0.3.12.dev26__tar.gz

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/PKG-INFO

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

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/docs/plain2code_cli.md

@@ -121,6 +121,8 @@ options:
   --headless            Run in headless mode: no TUI. Progress is written to
                         the log file and streamed to stdout as it happens; the
                         specification text itself stays in the log file only.
+                        Used automatically when stdin, stdout or stderr is not
+                        a terminal.
   --status              Display account status including user information, API
                         key label, and rendering credits. Does not render any
                         code.

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/file_utils.py

@@ -142,20 +142,7 @@ def get_existing_files_content(build_folder, existing_files):
     return existing_files_content
 
 
-def ensure_final_newline(content: str) -> str:
-    """Ends non-empty text with a newline, as linters expect (e.g. RuboCop, ESLint eol-last, Ruff W292)."""
-    if content and not content.endswith("\n"):
-        return content + "\n"
-    return content
-
-
 def store_response_files(target_folder, response_files, existing_files):
-    """Writes the files returned by the API to target_folder. None content deletes the file.
-
-    Every written file ends with a newline - whole-file rewrites come back from the API without one. The
-    added newline is also written back into response_files, so callers that diff response_files against
-    the folder afterwards see exactly what is on disk.
-    """
     for file_name in response_files:
         full_file_name = os.path.join(target_folder, file_name)
 
@@ -169,8 +156,6 @@ def store_response_files(target_folder, response_files, existing_files):
 
             continue
 
-        response_files[file_name] = ensure_final_newline(response_files[file_name])
-
         os.makedirs(os.path.dirname(full_file_name), exist_ok=True)
 
         with open(full_file_name, "w", encoding="utf-8") as f:

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/plain2code.py

@@ -161,6 +161,17 @@ def setup_logging(
     return logging.getLevelName(configured_log_level)
 
 
+def attached_to_terminal() -> bool:
+    """Whether a person at a terminal can see and drive the TUI.
+
+    The TUI reads keys from stdin and draws on stderr; the exit summary goes to
+    stdout. Started from a script or an agent, stdin is usually at end-of-file,
+    and Textual's input thread then reads EOF in a tight loop at 100% CPU while
+    a stopped render waits for an Enter nobody can press.
+    """
+    return all(stream is not None and stream.isatty() for stream in (sys.stdin, sys.stdout, sys.stderr))
+
+
 def _check_connection(codeplainAPI: codeplain_api.CodeplainAPI) -> Optional[str]:
     """Check API connectivity, validate API key and client version, and return the user email."""
     response = codeplainAPI.connection_check(system_config.client_version)
@@ -473,12 +484,21 @@ def main():  # noqa: C901
 
     run_state = RunState(spec_filename=args.filename, replay_with=args.replay_with)
 
+    # Without a terminal nobody can watch or drive the TUI, so render as --headless does:
+    # progress on stdout, and a non-zero exit status when the render stops.
+    no_terminal = not args.headless and not attached_to_terminal()
+    if no_terminal:
+        args.headless = True
+
     if args.headless:
         # Suppress Rich console output.
         console.quiet = True
 
     default_log_level = setup_logging(args, event_bus, run_state, args.log_to_file, args.log_file_name, args.headless)
 
+    if no_terminal:
+        console.info("No terminal attached, so rendering without the TUI, as with --headless.")
+
     initialize_telemetry()
 
     exc_info = None

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/plain2code_arguments.py

@@ -428,7 +428,8 @@ def create_parser():
         action="store_true",
         default=False,
         help="Run in headless mode: no TUI. Progress is written to the log file and streamed "
-        "to stdout as it happens; the specification text itself stays in the log file only.",
+        "to stdout as it happens; the specification text itself stays in the log file only. "
+        "Used automatically when stdin, stdout or stderr is not a terminal.",
     )
 
     parser.add_argument(

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/tests/test_file_utils.py

@@ -3,8 +3,7 @@ import tempfile
 
 import pytest
 
-from diff_utils import get_code_diff
-from file_utils import get_existing_files_content, load_linked_resources, store_response_files
+from file_utils import load_linked_resources, store_response_files
 from plain2code_exceptions import UnsupportedBase64Content, UnsupportedResourceType
 from plain2code_utils import MAX_BASE64_BLOB_LENGTH
 
@@ -85,64 +84,9 @@ def test_load_linked_resources_real_base64_image_raises(template_dir):
 def test_store_response_files_writes_unicode_as_utf8(template_dir):
     # Content with a non-cp1252 character (📍 U+1F4CD) must be written as UTF-8
     # regardless of the platform's default text encoding (e.g. cp1252 on Windows).
-    content = "Location 📍 marker\n"
+    content = "Location 📍 marker"
     store_response_files(template_dir, {"notes.md": content}, [])
 
     file_path = os.path.join(template_dir, "notes.md")
     with open(file_path, "rb") as f:
         assert f.read().decode("utf-8") == content
-
-
-def _read_bytes(folder, file_name):
-    with open(os.path.join(folder, file_name), "rb") as f:
-        return f.read().decode("utf-8")
-
-
-@pytest.mark.parametrize(
-    "content, expected",
-    [
-        ("class Foo\nend", "class Foo\nend\n"),
-        ("class Foo\nend\n", "class Foo\nend\n"),
-        ("class Foo\nend\n\n", "class Foo\nend\n\n"),
-        ("class Foo\r\nend\r\n", "class Foo\r\nend\r\n"),
-        ("", ""),
-    ],
-)
-def test_store_response_files_ends_every_text_file_with_a_newline(template_dir, content, expected):
-    # Linters gate on a final newline (RuboCop Layout/TrailingEmptyLines, ESLint eol-last, Ruff W292), so a
-    # whole-file rewrite that comes back without one must not reach the disk that way.
-    store_response_files(template_dir, {"app/foo.rb": content}, [])
-
-    assert _read_bytes(template_dir, "app/foo.rb") == expected
-
-
-def test_store_response_files_hands_back_the_content_it_wrote(template_dir):
-    # Callers diff the response files against the build folder after storing them (fix journal, conformance
-    # fixes handed to the unit tests fixer), so the response files must match what is on disk.
-    response_files = {"app/foo.rb": "class Foo\nend", "app/bar.rb": "class Bar\nend\n"}
-
-    store_response_files(template_dir, response_files, [])
-
-    assert response_files == {"app/foo.rb": "class Foo\nend\n", "app/bar.rb": "class Bar\nend\n"}
-
-
-def test_rewriting_a_file_without_its_final_newline_does_not_change_it(template_dir):
-    existing_files = store_response_files(template_dir, {"app/foo.rb": "class Foo\nend\n"}, [])
-    existing_files_content = get_existing_files_content(template_dir, existing_files)
-
-    rewrite = {"app/foo.rb": "class Foo\nend"}
-    store_response_files(template_dir, rewrite, existing_files)
-
-    assert get_existing_files_content(template_dir, existing_files) == existing_files_content
-    assert get_code_diff(rewrite, existing_files_content) == {}
-
-
-def test_store_response_files_still_deletes_a_file_whose_content_is_none(template_dir):
-    existing_files = store_response_files(template_dir, {"app/foo.rb": "class Foo\nend\n"}, [])
-
-    response_files = {"app/foo.rb": None}
-    store_response_files(template_dir, response_files, existing_files)
-
-    assert not os.path.exists(os.path.join(template_dir, "app/foo.rb"))
-    assert existing_files == []
-    assert response_files == {"app/foo.rb": None}

{codeplain-0.3.12.dev24 → codeplain-0.3.12.dev26}/tests/test_render_finished_report.py

@@ -122,6 +122,9 @@ def run_main(render_side_effect=None, api_key="test-key"):
             render_side_effect(run_state)
 
     with (
+        # The args ask for the TUI. Under pytest there is no terminal, which would
+        # otherwise switch the render to headless.
+        patch("plain2code.attached_to_terminal", return_value=True),
         patch("plain2code.parse_arguments", return_value=make_args(api_key=api_key)),
         patch("plain2code.file_utils.get_template_directories", return_value=["templates"]),
         patch("plain2code.plain_modules.PlainModule", return_value=MagicMock(all_required_modules=[])),

codeplain-0.3.12.dev26/tests/test_terminal_attachment.py

@@ -0,0 +1,295 @@
+"""How a render behaves with and without a terminal attached.
+
+The TUI needs a person at a terminal: it reads keys from stdin, draws on stderr,
+and the console summary goes to stdout. Started from a script or an agent
+(`codeplain module.plain > render.log 2>&1 &`), stdin is at end-of-file.
+Textual's input thread then reads EOF in a tight loop - millions of reads a
+second - so the process pins a CPU core for the whole render, and a stopped
+render waits for an Enter nobody can press. One such render stayed alive for
+an hour and a half at ~100% CPU until it was killed.
+
+So without a terminal codeplain runs as --headless does, and a stopped render
+exits non-zero. With a terminal the TUI is kept, and waiting for Enter must
+stay idle.
+"""
+
+import os
+import struct
+import subprocess
+import sys
+import textwrap
+import threading
+import time
+from argparse import Namespace
+from contextlib import ExitStack
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+import plain2code
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class FakeStream:
+    def __init__(self, is_terminal: bool):
+        self._is_terminal = is_terminal
+
+    def isatty(self) -> bool:
+        return self._is_terminal
+
+
+class TestAttachedToTerminal:
+    @pytest.fixture
+    def streams(self, monkeypatch):
+        def set_streams(stdin=True, stdout=True, stderr=True):
+            for name, value in (("stdin", stdin), ("stdout", stdout), ("stderr", stderr)):
+                monkeypatch.setattr(sys, name, value if value is None else FakeStream(value))
+
+        return set_streams
+
+    def test_all_three_streams_on_a_terminal(self, streams):
+        streams()
+
+        assert plain2code.attached_to_terminal() is True
+
+    @pytest.mark.parametrize("stream", ["stdin", "stdout", "stderr"])
+    def test_any_stream_off_the_terminal(self, streams, stream):
+        """stdin carries the keys, stderr the TUI, stdout the summary. Losing any
+        of them leaves a TUI nobody can drive or see."""
+        streams(**{stream: False})
+
+        assert plain2code.attached_to_terminal() is False
+
+    def test_a_closed_stream(self, streams):
+        """sys.stdin is None when the process has no stdin at all."""
+        streams(stdin=None)
+
+        assert plain2code.attached_to_terminal() is False
+
+
+def make_args():
+    return Namespace(
+        version=False,
+        status=False,
+        full_plain=False,
+        dry_run=False,
+        api_key="test-key",
+        api="https://api.example.com",
+        filename="project.plain",
+        template_dir=None,
+        build_folder="build",
+        render_range=None,
+        render_from=None,
+        force_render=False,
+        headless=False,
+        replay_with=None,
+        log_to_file=False,
+        log_file_name="codeplain.log",
+        render_conformance_tests=False,
+        conformance_tests_script=None,
+        unittests_script=None,
+        prepare_environment_script=None,
+    )
+
+
+def run_render(succeeded, terminal, render_state=None, render_choices=None):
+    """Drive the real main() and render() up to the module renderer.
+
+    The module renderer stands in for the state machine: it decides how the
+    render ended. Everything the decision under test does not touch - the API,
+    parsing, logging, telemetry - is stubbed.
+
+    Returns the mocks for the two TUIs and the module renderer, the args main()
+    rendered with, and the exit status it asked for (None when it returned
+    normally).
+    """
+    args = make_args()
+    module_renderer = MagicMock()
+
+    def make_module_renderer(codeplainAPI, plain_module, render_choice, render_range, args, run_state, *rest, **kw):
+        module_renderer.render_module.side_effect = lambda: run_state.set_render_succeeded(succeeded)
+        return module_renderer
+
+    progress_tui = MagicMock()
+    progress_tui.return_value.run.side_effect = lambda: progress_tui.call_args.kwargs["on_ready"]()
+    choice_tui = MagicMock()
+
+    patches = [
+        patch("plain2code.attached_to_terminal", return_value=terminal),
+        patch("plain2code.parse_arguments", return_value=args),
+        patch("plain2code.file_utils.get_template_directories", return_value=["templates"]),
+        patch("plain2code.plain_modules.PlainModule", return_value=MagicMock(all_required_modules=[])),
+        patch("plain2code.setup_logging", return_value="INFO"),
+        patch("plain2code.initialize_telemetry"),
+        patch("plain2code.stop_narrating"),
+        patch("plain2code.print_exit_summary"),
+        patch("plain2code.dump_crash_logs"),
+        patch("plain2code.capture_crash"),
+        patch("plain2code.codeplain_api.CodeplainAPI"),
+        patch("plain2code._check_connection", return_value="user@codeplain.ai"),
+        patch("plain2code.signal.signal"),
+        patch("plain2code.warn_if_acceptance_tests_without_conformance_script"),
+        patch("plain2code.get_plain_module_render_state", return_value=render_state),
+        patch("plain2code.get_render_choices", return_value=render_choices),
+        patch("plain2code.ModuleRenderer", side_effect=make_module_renderer),
+        patch("plain2code.Plain2CodeTUI", progress_tui),
+        patch("plain2code.PlainModuleRenderChoiceTUI", choice_tui),
+        patch.object(plain2code.console, "quiet", plain2code.console.quiet),
+    ]
+
+    exit_status = None
+    with ExitStack() as stack:
+        for each in patches:
+            stack.enter_context(each)
+        try:
+            plain2code.main()
+        except SystemExit as e:
+            exit_status = e.code
+
+    return Namespace(
+        progress_tui=progress_tui,
+        choice_tui=choice_tui,
+        module_renderer=module_renderer,
+        exit_status=exit_status,
+        args=args,
+    )
+
+
+class TestRenderWithoutATerminal:
+    def test_the_tui_never_starts(self):
+        result = run_render(succeeded=False, terminal=False)
+
+        result.progress_tui.assert_not_called()
+        result.module_renderer.render_module.assert_called_once()
+
+    def test_a_stopped_render_exits_non_zero(self):
+        """The status --headless gives, so a script can tell it stopped."""
+        result = run_render(succeeded=False, terminal=False)
+
+        assert result.exit_status == 1
+
+    def test_a_completed_render_exits_cleanly(self):
+        result = run_render(succeeded=True, terminal=False)
+
+        assert result.exit_status is None
+
+    def test_says_why_it_runs_without_the_tui(self, caplog):
+        caplog.set_level("INFO", logger="codeplain")
+
+        run_render(succeeded=True, terminal=False)
+
+        assert "No terminal attached" in caplog.text
+
+    def test_never_asks_where_to_resume(self):
+        """The choice prompt is a TUI too, and would wait for a key just the same."""
+        destructive = MagicMock(is_destructive=True)
+        choices = {"restart": destructive, "other": MagicMock(), "quit": MagicMock()}
+
+        result = run_render(succeeded=True, terminal=False, render_state=MagicMock(), render_choices=choices)
+
+        result.choice_tui.assert_not_called()
+
+
+class TestRenderWithATerminal:
+    def test_the_tui_still_runs(self):
+        result = run_render(succeeded=True, terminal=True)
+
+        result.progress_tui.assert_called_once()
+        assert result.args.headless is False
+
+    def test_says_nothing_about_a_missing_terminal(self, caplog):
+        caplog.set_level("INFO", logger="codeplain")
+
+        run_render(succeeded=True, terminal=True)
+
+        assert "No terminal attached" not in caplog.text
+
+
+IDLE_SECONDS = 2.0
+
+# Drives the real TUI to the stopped state, then measures the CPU the process
+# spends over IDLE_SECONDS while it waits for Enter.
+STOPPED_TUI = textwrap.dedent("""
+    import os, sys, threading, time
+
+    from event_bus import EventBus
+    from plain2code_events import RenderFailed
+    from plain2code_state import RunState
+    from tui.plain2code_tui import Plain2CodeTUI
+
+    report_path, idle_seconds = sys.argv[1], float(sys.argv[2])
+    event_bus = EventBus()
+
+    def stop_then_measure():
+        event_bus.publish(RenderFailed(error_message="unit tests still failing"))
+        start = time.process_time()
+        time.sleep(idle_seconds)
+        with open(report_path + ".tmp", "w") as report:
+            report.write(str(time.process_time() - start))
+        os.replace(report_path + ".tmp", report_path)
+
+    Plain2CodeTUI(
+        event_bus=event_bus,
+        run_state=RunState(spec_filename="x.plain"),
+        on_ready=threading.Thread(target=stop_then_measure, daemon=True).start,
+        render_id="test",
+        unittests_script=None,
+        conformance_tests_script=None,
+        prepare_environment_script=None,
+        state_machine_version="0.0.0",
+        css_path="styles.css",
+    ).run()
+    """)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="needs a POSIX pseudo-terminal")
+def test_a_stopped_render_on_a_terminal_waits_for_enter_without_spinning(tmp_path):
+    # Unix-only modules: imported here so Windows can still collect the other tests in this file.
+    import fcntl
+    import termios
+
+    controller, terminal = os.openpty()
+    fcntl.ioctl(terminal, termios.TIOCSWINSZ, struct.pack("HHHH", 30, 100, 0, 0))
+    report = tmp_path / "cpu_seconds"
+
+    process = subprocess.Popen(
+        [sys.executable, "-c", STOPPED_TUI, str(report), str(IDLE_SECONDS)],
+        stdin=terminal,
+        stdout=terminal,
+        stderr=terminal,
+        cwd=REPO_ROOT,
+        env={**os.environ, "TERM": "xterm-256color"},
+        start_new_session=True,
+    )
+    os.close(terminal)
+
+    def drain():
+        # The TUI blocks once the terminal buffer fills, so keep reading it.
+        try:
+            while os.read(controller, 65536):
+                pass
+        except OSError:
+            pass
+
+    threading.Thread(target=drain, daemon=True).start()
+
+    try:
+        deadline = time.monotonic() + 60
+        while not report.exists():
+            assert process.poll() is None, "the TUI exited before Enter was pressed"
+            assert time.monotonic() < deadline, "the TUI never reached the stopped state"
+            time.sleep(0.1)
+        cpu_seconds = float(report.read_text())
+
+        os.write(controller, b"\r")
+        exit_status = process.wait(timeout=15)
+    finally:
+        if process.poll() is None:
+            process.kill()
+            process.wait()
+        os.close(controller)
+
+    # A busy loop burns about one CPU-second per second of waiting.
+    assert cpu_seconds < IDLE_SECONDS / 4
+    assert exit_status == 0