UI changes.

Author: zanjonke

module_renderer.py

@@ -2,15 +2,11 @@
 import os
 import threading
 
-import git_utils
-import plain_file
-import plain_spec
 from event_bus import EventBus
 from memory_management import MemoryManager
-from partial_rendering import PartialRenderChoice
+from partial_rendering import RenderChoice
 from plain2code_console import console
 from plain2code_events import RenderCompleted, RenderFailed
-from plain2code_exceptions import MissingPreviousFunctionalitiesError
 from plain2code_state import RunState
 from plain_modules import PlainModule
 from render_machine.code_renderer import CodeRenderer
@@ -24,7 +20,7 @@ def __init__(
         self,
         codeplainAPI,
         plain_module: PlainModule,
-        partial_render_choice: PartialRenderChoice | None,
+        render_choice: RenderChoice | None,
         render_range: list[str] | None,
         args: argparse.Namespace,
         run_state: RunState,
@@ -34,126 +30,14 @@ def __init__(
     ):
         self.codeplainAPI = codeplainAPI
         self.plain_module = plain_module
-        self.partial_render_choice = partial_render_choice
+        self.render_choice = render_choice
         self.render_range = render_range
         self.args = args
         self.run_state = run_state
         self.event_bus = event_bus
         self.stop_event = stop_event
         self.enter_pause_event = enter_pause_event
 
-    def _ensure_module_folders_exist(self, module_name: str, first_render_frid: str) -> tuple[str, str]:
-        """
-        Ensure that build and conformance test folders exist for the module.
-
-        Args:
-            module_name: Name of the module being rendered
-            first_render_frid: The first FRID in the render range
-
-        Returns:
-            tuple[str, str]: (build_folder_path, conformance_tests_path)
-
-        Raises:
-            MissingPreviousFridCommitsError: If any required folders are missing
-        """
-        build_folder_path = os.path.join(self.args.build_folder, module_name)
-        conformance_tests_path = os.path.join(self.args.conformance_tests_folder, module_name)
-
-        if not os.path.exists(build_folder_path):
-            raise MissingPreviousFunctionalitiesError(
-                "Error rendering plain code: "
-                f"Cannot start rendering from functionality {first_render_frid} for module '{module_name}' because the source code folder does not exist.\n\n"
-                f"To fix this, please render the module from the beginning by running:\n"
-                f"  codeplain {module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION}\n"
-            )
-
-        if not os.path.exists(conformance_tests_path) and self.args.render_conformance_tests:
-            raise MissingPreviousFunctionalitiesError(
-                "Error rendering plain code: "
-                f"Cannot start rendering from functionality {first_render_frid} for module '{module_name}' because the conformance tests folder does not exist.\n\n"
-                f"To fix this, please render the module from the beginning by running:\n"
-                f"  codeplain {module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION}\n"
-            )
-
-        return build_folder_path, conformance_tests_path
-
-    def _ensure_frid_commit_exists(
-        self,
-        frid: str,
-        module_name: str,
-        build_folder_path: str,
-        conformance_tests_path: str,
-        first_render_frid: str,
-    ) -> None:
-        """
-        Ensure commit exists for a single FRID in both repositories.
-
-        Args:
-            frid: The FRID to check
-            module_name: Name of the module
-            build_folder_path: Path to the build folder
-            conformance_tests_path: Path to the conformance tests folder
-            first_render_frid: The first FRID in the render range (for error messages)
-
-        Raises:
-            MissingPreviousFridCommitsError: If the commit is missing
-        """
-        # Check in build folder
-        if not git_utils.has_commit_for_frid(build_folder_path, frid, module_name):
-            raise MissingPreviousFunctionalitiesError(
-                "Error rendering plain code: "
-                f"Cannot start rendering from functionality {first_render_frid} for module '{module_name}' because the implementation of the previous functionality ({frid}) hasn't been completed yet.\n\n"
-                f"To fix this, please render the missing functionality ({frid}) first by running:\n"
-                f"  codeplain {module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION} --render-from {frid}\n"
-            )
-
-        # Check in conformance tests folder (only if conformance tests are enabled)
-        if self.args.render_conformance_tests:
-            if not git_utils.has_commit_for_frid(conformance_tests_path, frid, module_name):
-                raise MissingPreviousFunctionalitiesError(
-                    "Error rendering plain code: "
-                    f"Cannot start rendering from functionality {first_render_frid} for module '{module_name}' because the conformance tests for the previous functionality ({frid}) haven't been completed yet.\n\n"
-                    f"To fix this, please render the missing functionality ({frid}) first by running:\n"
-                    f"  codeplain {module_name}{plain_file.PLAIN_SOURCE_FILE_EXTENSION} --render-from {frid}\n"
-                )
-
-    def _ensure_previous_frid_commits_exist(
-        self, module_name: str, plain_source: dict, render_range: list[str]
-    ) -> None:
-        """
-        Ensure that all FRID commits before the render_range exist.
-
-        This is a precondition check that must pass before rendering can proceed.
-        Raises an exception if any previous FRID commits are missing.
-
-        Args:
-            module_name: Name of the module being rendered
-            plain_source: The plain source tree
-            render_range: List of FRIDs to render
-
-        Raises:
-            MissingPreviousFridCommitsError: If any previous FRID commits are missing
-        """
-        first_render_frid = render_range[0]
-
-        # Get all FRIDs that should have been rendered before this one
-        previous_frids = plain_spec.get_frids_before(plain_source, first_render_frid)
-        if not previous_frids:
-            return
-
-        # Ensure the module folders exist
-        build_folder_path, conformance_tests_path = self._ensure_module_folders_exist(module_name, first_render_frid)
-
-        # Verify commits exist for all previous FRIDs
-        for prev_frid in previous_frids:
-            self._ensure_frid_commit_exists(
-                prev_frid,
-                module_name,
-                build_folder_path,
-                conformance_tests_path,
-                first_render_frid,
-            )
-
     def _build_render_context_for_module(
         self,
         plain_module: PlainModule,
@@ -192,20 +76,20 @@ def _render_module(
         Returns:
             tuple[bool, bool]: (Whether the module was rendered and whether the rendering failed)
         """
-        is_partial_render_choice_module = (
-            self.partial_render_choice is not None
-            and self.partial_render_choice.module is not None
-            and self.partial_render_choice.module.module_name == plain_module.module_name
+        is_render_choice_module = (
+            self.render_choice is not None
+            and self.render_choice.module is not None
+            and self.render_choice.module.module_name == plain_module.module_name
         )
 
-        if is_partial_render_choice_module:
-            render_range = self.partial_render_choice.render_range
+        if is_render_choice_module:
+            render_range = self.render_choice.render_range
 
         if render_range is not None:
             plain_module.ensure_previous_frid_commits_exist(render_range, self.args.render_conformance_tests)
 
         has_any_required_module_changed = False
-        if not self.args.render_machine_graph and plain_module.required_modules and not is_partial_render_choice_module:
+        if not self.args.render_machine_graph and plain_module.required_modules and not is_render_choice_module:
             console.debug(f"Analyzing required modules of module {plain_module.module_name}...")
             for required_module in plain_module.required_modules:
                 has_module_changed, rendering_failed = self._render_module(
@@ -226,7 +110,7 @@ def _render_module(
             and not has_any_required_module_changed
             and not plain_module.has_plain_spec_changed()
             and not plain_module.has_required_modules_code_changed()
-            and not is_partial_render_choice_module
+            and not is_render_choice_module
         ):
             return False, False
 
@@ -264,11 +148,11 @@ def _render_module(
         return True, False
 
     def render_module(self) -> None:
-        if self.partial_render_choice is not None and self.partial_render_choice.wipe_later_modules:
+        if self.render_choice is not None and self.render_choice.wipe_later_modules:
             later_module = False
             all_modules = self.plain_module.all_required_modules + [self.plain_module]
             for module in all_modules:
-                if module.module_name == self.partial_render_choice.module.module_name:
+                if module.module_name == self.render_choice.module.module_name:
                     later_module = True
                     continue
 

partial_rendering.py

@@ -7,20 +7,20 @@
 
 
 @dataclass
-class PartialRender:
+class PlainModuleRenderState:
     last_render_module: PlainModule
     last_render_frid: str | None
     change: PlainModule | None = None
     change_type: Literal["spec_change", "code_change"] | None = None
 
 
 @dataclass
-class PartialRenderChoice:
+class RenderChoice:
     module: PlainModule | None = None
     render_range: list[str] | None = None
-    msg: str | None = None
     wipe_later_modules: bool = False
-    is_desctructive: bool = False
+    is_destructive: bool = False
+    choice_type: str | None = None
 
 
 def spec_change(plain_module: PlainModule) -> PlainModule | None:
@@ -70,7 +70,7 @@ def module_comes_before_or_equal(
     raise ValueError(f"Module {module1.module_name} and {module2.module_name} not found in {all_required_modules}")
 
 
-def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
+def get_plain_module_render_state(plain_module: PlainModule) -> PlainModuleRenderState | None:
     sc = spec_change(plain_module)
     cc = code_change(plain_module)
     all_required_modules = plain_module.all_required_modules
@@ -92,7 +92,7 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
             )
         module = found_module
 
-    pr = PartialRender(
+    pr = PlainModuleRenderState(
         last_render_module=module,
         last_render_frid=last_rendered_frid,
         change=None,
@@ -116,91 +116,109 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
     return pr
 
 
-def get_choices(
+def get_all_affected_modules_from_change(
     plain_module: PlainModule,
-    partial_render: PartialRender,
+    plain_module_render_state: PlainModuleRenderState,
+) -> list[PlainModule]:
+    all_affected_modules = list[PlainModule]()
+
+    if plain_module_render_state.change_type == "spec_change":
+        start_module = plain_module_render_state.change
+    elif plain_module_render_state.change_type == "code_change":
+        if plain_module_render_state.change.is_module_fully_rendered():
+            start_module = plain_module.get_next_module(plain_module_render_state.change.module_name)
+        else:
+            start_module = plain_module_render_state.change
+    else:
+        raise ValueError(f"Unknown change type: {plain_module_render_state.change_type}")
+
+    affected_module = False
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for module in all_modules:
+        if module.module_name == start_module.module_name:
+            affected_module = True
+
+        if affected_module:
+            all_affected_modules.append(module)
+
+    return all_affected_modules
+
+
+def get_render_choices(
+    plain_module: PlainModule,
+    plain_module_render_state: PlainModuleRenderState,
     force_render: bool = False,
-) -> dict[str, PartialRenderChoice]:
-    choices = dict[str, PartialRenderChoice]()
+) -> dict[str, RenderChoice]:
+    choices = dict[str, RenderChoice]()
     choice_idx = 1
 
-    if partial_render.last_render_module.is_initial_module():
-        choices[str(choice_idx)] = PartialRenderChoice(
-            module=partial_render.last_render_module,
+    if plain_module_render_state.last_render_module.is_initial_module():
+        choices[str(choice_idx)] = RenderChoice(
+            module=plain_module_render_state.last_render_module,
             render_range=None,
-            msg=f"Start from module [#5593FF]{partial_render.last_render_module.module_name}[/]",
+            choice_type="module_start",
             wipe_later_modules=True,
-            is_desctructive=False,
+            is_destructive=False,
         )
         choice_idx += 1
 
-    elif not partial_render.last_render_module.is_module_fully_rendered():
-        if not partial_render.last_render_frid:
+    elif not plain_module_render_state.last_render_module.is_module_fully_rendered():
+        if not plain_module_render_state.last_render_frid:
             raise ValueError("Last render FRID is not set for a non-initial module")
 
         next_frid, next_module = plain_module.get_next_frid(
-            partial_render.last_render_frid, partial_render.last_render_module.module_name
+            plain_module_render_state.last_render_frid, plain_module_render_state.last_render_module.module_name
         )
         render_range = plain_spec.get_render_range_from(next_frid, next_module.plain_source)
-        msg = "Continue from"
-        if next_frid != plain_spec.get_first_frid(next_module.plain_source):
-            msg += f" functionality [#5593FF]{next_frid}[/]"
-        else:
-            msg += f" module [#5593FF]{next_module.module_name}[/]"
 
-        choices[str(choice_idx)] = PartialRenderChoice(
+        choices[str(choice_idx)] = RenderChoice(
             module=next_module,
             render_range=render_range if not force_render else None,
             wipe_later_modules=force_render,
-            msg=msg,
+            choice_type="continue_from_frid",
         )
         choice_idx += 1
 
     else:
-        next_module = plain_module.get_next_module(partial_render.last_render_module.module_name)
+        next_module = plain_module.get_next_module(plain_module_render_state.last_render_module.module_name)
         if next_module is None:
-            next_module = partial_render.last_render_module
+            next_module = plain_module_render_state.last_render_module
 
-        choices[str(choice_idx)] = PartialRenderChoice(
+        choices[str(choice_idx)] = RenderChoice(
             module=next_module,
             render_range=None,
-            msg=f"Start from module [#5593FF]{next_module.module_name}[/]",
-            is_desctructive=partial_render.last_render_module.module_name == plain_module.module_name,
+            is_destructive=plain_module_render_state.last_render_module.module_name == plain_module.module_name,
+            choice_type="module_start",
         )
         choice_idx += 1
 
-    if partial_render.change:
-        all_affected_modules = list[str]()
-        affected_module = False
-        for module in plain_module.all_required_modules:
-            if module.module_name == partial_render.change.module_name:
-                affected_module = True
-            if affected_module:
-                all_affected_modules.append(module.module_name)
+    if plain_module_render_state.change:
+        all_affected_modules = get_all_affected_modules_from_change(plain_module, plain_module_render_state)
 
         if len(all_affected_modules) > 0:
-            choices[str(choice_idx)] = PartialRenderChoice(
-                module=partial_render.change,
+            choices[str(choice_idx)] = RenderChoice(
+                module=all_affected_modules[0],
                 render_range=None,
-                msg=f"Re-render all affected modules ([#5593FF]{', '.join(all_affected_modules)}[/])",
+                choice_type="rerender_affected",
                 wipe_later_modules=True,
-                is_desctructive=True,
+                is_destructive=True,
             )
             choice_idx += 1
 
     if len(plain_module.all_required_modules) > 0:
         first_module = plain_module.all_required_modules[0]
-        if first_module.module_name != partial_render.last_render_module.module_name and (
-            partial_render.change is not None and first_module.module_name != partial_render.change.module_name
+        if first_module.module_name != plain_module_render_state.last_render_module.module_name and (
+            plain_module_render_state.change is not None
+            and first_module.module_name != plain_module_render_state.change.module_name
         ):
-            choices[str(choice_idx)] = PartialRenderChoice(
+            choices[str(choice_idx)] = RenderChoice(
                 module=first_module,
                 render_range=None,
-                msg=f"Re-render from first module ([#5593FF]{first_module.module_name}[/])",
+                choice_type="rerender_from_first",
                 wipe_later_modules=True,
-                is_desctructive=True,
+                is_destructive=True,
             )
             choice_idx += 1
 
-    choices[str(choice_idx)] = PartialRenderChoice(module=None, render_range=None, msg="Quit")
+    choices[str(choice_idx)] = RenderChoice(module=None, render_range=None, choice_type="quit")
     return choices