Refactoring partial_render_tui.py

Author: zanjonke

git_utils.py

@@ -435,22 +435,51 @@ def get_repo_info(repo_path: Union[str, os.PathLike]) -> dict:
     return info
 
 
-def get_last_finished_frid(repo_path: Union[str, os.PathLike]) -> tuple[Optional[str], Optional[str]]:
+def get_last_rendered_functionality(repo_path: Union[str, os.PathLike]) -> tuple[Optional[str], Optional[str]]:
     if not os.path.exists(repo_path):
         return None, None
 
     repo = Repo(repo_path)
     grep_pattern = FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE.format(".*")
     grep_pattern = grep_pattern.replace("[", "\\[").replace("]", "\\]")
     commit_sha = repo.git.rev_list(repo.active_branch.name, "--grep", grep_pattern, "-n", "1")
+
     if not commit_sha:
-        return None, None
+        # Repo was interrupted during the first functionality, fallback to initial commit and provide only module name
+        grep_pattern = INITIAL_COMMIT_MESSAGE
+        grep_pattern = grep_pattern.replace("[", "\\[").replace("]", "\\]")
+        commit_sha = repo.git.rev_list(repo.active_branch.name, "--grep", grep_pattern, "-n", "1")
+        if not commit_sha:
+            raise InvalidGitRepositoryError("Git repository is in an invalid state. Initial commit could not be found.")
+
+        commit_message = repo.commit(commit_sha).message
+        if isinstance(commit_message, bytes):
+            commit_message = commit_message.decode("utf-8")
+
+        match = re.search(r"Module name:\s*(\S+)\n", commit_message)
+        if not match:
+            raise InvalidGitRepositoryError(
+                "Git repository is in an invalid state. Could not find module name in initial commit."
+            )
+
+        module_name = match.group(1)
+        return module_name, None
+
     commit_message = repo.commit(commit_sha).message
     if isinstance(commit_message, bytes):
         commit_message = commit_message.decode("utf-8")
+
     match = re.search(r"FRID\):(\S+) fully implemented", commit_message)
-    frid = match.group(1) if match else None
+    if not match:
+        raise InvalidGitRepositoryError(
+            "Git repository is in an invalid state. Could not find frid in finished commit."
+        )
+    frid = match.group(1)
 
     match = re.search(r"Module name:\s*(\S+)\n", commit_message)
-    module_name = match.group(1) if match else None
+    if not match:
+        raise InvalidGitRepositoryError(
+            "Git repository is in an invalid state. Could not find module name in finished commit."
+        )
+    module_name = match.group(1)
     return module_name, frid

partial_rendering.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Literal
 
 import plain_spec
 from plain2code_exceptions import ModuleDoesNotExistError
@@ -10,7 +11,7 @@ class PartialRender:
     last_render_module: PlainModule
     last_render_frid: str | None
     change: PlainModule | None = None
-    change_type: str | None = None
+    change_type: Literal["spec_change", "code_change"] | None = None
 
 
 @dataclass
@@ -21,43 +22,27 @@ class PartialRenderChoice:
 
 
 def spec_change(plain_module: PlainModule) -> PlainModule | None:
-    for required_module in plain_module.all_required_modules:
-        module_metadata = required_module.load_module_metadata()
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for _module in all_modules:
+        module_metadata = _module.load_module_metadata()
         if (
             module_metadata
             and "source_hash" in module_metadata
-            and module_metadata["source_hash"] != required_module.get_module_source_hash()
+            and module_metadata["source_hash"] != _module.get_module_source_hash()
         ):
-            return required_module
-
-    module_metadata = plain_module.load_module_metadata()
-    if (
-        module_metadata
-        and "source_hash" in module_metadata
-        and module_metadata["source_hash"] != plain_module.get_module_source_hash()
-    ):
-        return plain_module
+            return _module
 
     return None
 
 
 def code_change(plain_module: PlainModule) -> PlainModule | None:
-    for required_module in plain_module.all_required_modules:
-        if len(required_module.required_modules) == 0:
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for _module in all_modules:
+        if len(_module.required_modules) == 0:
             continue
 
-        module_metadata = required_module.load_module_metadata()
-        previous_module = required_module.required_modules[-1]
-        if (
-            module_metadata
-            and "required_modules_code_hash" in module_metadata
-            and module_metadata["required_modules_code_hash"] != previous_module.get_module_code_hash()
-        ):
-            return previous_module
-
-    module_metadata = plain_module.load_module_metadata()
-    if len(plain_module.required_modules) > 0:
-        previous_module = plain_module.required_modules[-1]
+        module_metadata = _module.load_module_metadata()
+        previous_module = _module.required_modules[-1]
         if (
             module_metadata
             and "required_modules_code_hash" in module_metadata
@@ -68,7 +53,7 @@ def code_change(plain_module: PlainModule) -> PlainModule | None:
     return None
 
 
-def module_comes_before(
+def module_comes_before_or_equal(
     all_required_modules: list[PlainModule],
     module1: PlainModule,
     module2: PlainModule,
@@ -87,16 +72,11 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
     sc = spec_change(plain_module)
     cc = code_change(plain_module)
     all_required_modules = plain_module.all_required_modules
-    last_rendered_module, last_rendered_frid = plain_module.get_last_rendered_frid()
-    if last_rendered_module is None and last_rendered_frid is None:
+    last_rendered_module_name, last_rendered_frid = plain_module.get_module_last_rendered_functionality()
+    if last_rendered_module_name is None and last_rendered_frid is None:
         return None
 
-    module = None
-    for required_module in all_required_modules:
-        if required_module.module_name == last_rendered_module:
-            module = required_module
-
-    if last_rendered_module == plain_module.module_name:
+    if last_rendered_module_name == plain_module.module_name:
         if (
             last_rendered_frid is None
             or plain_spec.get_next_frid(plain_module.plain_source, last_rendered_frid) is not None
@@ -105,9 +85,14 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
         else:
             return None
 
+    module = None
+    for required_module in all_required_modules:
+        if required_module.module_name == last_rendered_module_name:
+            module = required_module
+
     if module is None:
         raise ModuleDoesNotExistError(
-            f"Last rendered module {last_rendered_module} not found in {[rmodule.module_name for rmodule in all_required_modules]}"
+            f"Last rendered module {last_rendered_module_name} not found in {[rmodule.module_name for rmodule in all_required_modules]}"
         )
 
     pr = PartialRender(
@@ -125,9 +110,73 @@ def detect_partial_rendering(plain_module: PlainModule) -> PartialRender | None:
         pr.change_type = "spec_change"
 
     if cc is not None and (
-        pr.change is None or (pr.change is not None and module_comes_before(all_required_modules, cc, pr.change))
+        pr.change is None
+        or (pr.change is not None and module_comes_before_or_equal(all_required_modules, cc, pr.change))
     ):
         pr.change = cc
         pr.change_type = "code_change"
 
     return pr
+
+
+def get_choices(plain_module: PlainModule, partial_render: PartialRender) -> dict[str, PartialRenderChoice]:
+    choices = dict[str, PartialRenderChoice]()
+    choice_idx = 1
+    if not partial_render.last_render_module.is_module_fully_rendered():
+        choices[str(choice_idx)] = PartialRenderChoice(
+            module=partial_render.last_render_module,
+            render_range=None,
+            msg=f"Start from module [#5593FF]{partial_render.last_render_module.module_name}[/]",
+        )
+        choice_idx += 1
+        if not partial_render.last_render_module.is_initial_module():
+            if not partial_render.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
+            )
+            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(
+                module=next_module,
+                render_range=render_range,
+                msg=msg,
+            )
+            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)
+
+        choices[str(choice_idx)] = PartialRenderChoice(
+            module=partial_render.change,
+            render_range=None,
+            msg=f"Re-render all affected modules ([#5593FF]{', '.join(all_affected_modules)}[/])",
+        )
+        choice_idx += 1
+
+    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
+    ):
+        choices[str(choice_idx)] = PartialRenderChoice(
+            module=first_module,
+            render_range=None,
+            msg=f"Re-render from first module ([#5593FF]{first_module.module_name}[/])",
+        )
+        choice_idx += 1
+
+    choices[str(choice_idx)] = PartialRenderChoice(module=None, render_range=None, msg="Quit")
+
+    return choices

plain2code.py

@@ -19,7 +19,7 @@
 import plain_spec
 from event_bus import EventBus
 from module_renderer import ModuleRenderer
-from partial_rendering import detect_partial_rendering
+from partial_rendering import detect_partial_rendering, get_choices
 from plain2code_arguments import parse_arguments
 from plain2code_console import console
 from plain2code_events import RenderFailed
@@ -181,20 +181,26 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
     if render_range is None:
         partial_render = detect_partial_rendering(plain_module)
         if partial_render is not None:
-            app = PartialRenderTUI(
-                plain_module,
-                partial_render,
-                system_config.client_version,
-                run_state.render_id,
-                css_path="styles.css",
-            )
-            partial_render_choice = app.run()
-            if partial_render_choice is None or (
-                partial_render_choice.module is None
-                and partial_render_choice.render_range is None
-                and partial_render_choice.msg == "Quit"
-            ):
-                exit()
+            choices = get_choices(plain_module, partial_render)
+            if len(choices) > 2:
+                app = PartialRenderTUI(
+                    plain_module,
+                    partial_render,
+                    choices,
+                    system_config.client_version,
+                    run_state.render_id,
+                    css_path="styles.css",
+                )
+                partial_render_choice = app.run()
+                if partial_render_choice is None or (
+                    partial_render_choice.module is None
+                    and partial_render_choice.render_range is None
+                    and partial_render_choice.msg == "Quit"
+                ):
+                    sys.exit(0)
+            else:
+                # Last choice is Quit, first choice is the only other actionable choice
+                partial_render_choice = choices[list(choices.keys())[0]]
 
     # We can't have both partial render choice and render range
     assert not (partial_render_choice is not None and render_range is not None)

plain_modules.py

@@ -68,18 +68,18 @@ def module_build_folder(self):
     def get_codeplain_folder(self):
         return os.path.join(self.module_build_folder, CODEPLAIN_METADATA_FOLDER)
 
-    def get_last_rendered_frid(self) -> tuple[str | None, str | None]:
+    def get_module_last_rendered_functionality(self) -> tuple[str | None, str | None]:
         if len(self.required_modules) == 0:
-            return git_utils.get_last_finished_frid(self.module_build_folder)
+            return git_utils.get_last_rendered_functionality(self.module_build_folder)
 
-        module_name, frid = git_utils.get_last_finished_frid(self.module_build_folder)
-        if module_name is not None and frid is not None and module_name == self.module_name:
+        module_name, frid = git_utils.get_last_rendered_functionality(self.module_build_folder)
+        if module_name is not None and module_name == self.module_name:
             return module_name, frid
 
         for module in reversed(self.required_modules):
-            last_rendered_module, last_rendered_frid = module.get_last_rendered_frid()
-            if last_rendered_module is not None and last_rendered_frid is not None:
-                return last_rendered_module, last_rendered_frid
+            last_rendered_module_name, last_rendered_frid = module.get_module_last_rendered_functionality()
+            if last_rendered_module_name is not None:
+                return last_rendered_module_name, last_rendered_frid
 
         return None, None
 
@@ -310,8 +310,28 @@ def get_next_frid(self, frid: str, module_name: str) -> tuple[str, PlainModule]:
 
     def is_module_fully_rendered(self) -> bool:
         frids = list(plain_spec.get_frids(self.plain_source))
-        last_rendered_module, last_rendered_frid = git_utils.get_last_finished_frid(self.module_build_folder)
-        if last_rendered_module is None or last_rendered_frid is None:
-            return False
+        last_rendered_module_name, last_rendered_frid = git_utils.get_last_rendered_functionality(
+            self.module_build_folder
+        )
+        if (
+            last_rendered_module_name is not None
+            and last_rendered_module_name == self.module_name
+            and last_rendered_frid is not None
+            and last_rendered_frid == frids[-1]
+        ):
+            return True
+
+        return False
+
+    def is_initial_module(self) -> bool:
+        last_rendered_module_name, last_rendered_frid = git_utils.get_last_rendered_functionality(
+            self.module_build_folder
+        )
+        if (
+            last_rendered_module_name is not None
+            and last_rendered_module_name == self.module_name
+            and last_rendered_frid is None
+        ):
+            return True
 
-        return last_rendered_frid == frids[-1]
+        return False