gitnc 0.1.2__tar.gz → 0.1.3__tar.gz

{gitnc-0.1.2 → gitnc-0.1.3}/CLAUDE.md

@@ -50,11 +50,13 @@ The two File menu entries (`action_short_file_list` / `action_long_file_list`) a
 
 Menu chrome is composed once and stays mounted, so `action_set_theme` / `_load_saved_theme` call `_restyle_menu_mnemonics()` to re-render the labels; otherwise they would keep the accelerator style of the theme that was active at compose time.
 
+**Starting inside a submodule:** `on_mount` loads nothing until `_offer_top_level_repository()` has settled which repository to read. `GIT.repository_chain()` returns this repo's top level followed by each superproject (`git rev-parse --show-superproject-working-tree`, asked again from every repository it finds), so nesting of any depth ends at the outermost one; a chain of one means not a submodule and the app starts at once. Otherwise a `_show_confirm()` lists the chain and asks to start in the last entry: Y goes through `_switch_repository()` — a new `GIT`, `repo_path`, and `os.chdir()` so the `Ctrl+O` shell lands there too — N keeps the submodule. Either answer then runs `_start()` (first loads, then the Midnight Commander warning), so the two startup questions come one after the other rather than stacked. The walk is a `rev-parse` per level, which doesn't grow with the repo, so it runs inline.
+
 **Chrome colors:** the menu bar and the footer are painted from four `UITheme` fields — `menu_bar_background` / `menu_bar_foreground` / `footer_background` / `footer_foreground` — which `css_variables()` emits as `$menu-bar-background`, `$menu-bar-foreground`, `$footer-background` and `$footer-foreground` (the last two are Textual's own Footer variables, so the app carries no `Footer` CSS at all). The defaults are `$panel` / `$foreground`, i.e. Textual's Header/Footer palette, so a theme that says nothing about the chrome gets the bars every other Textual app has; `midnight-commander.yaml` overrides all four to `$warning` / `$background` for the MC look. Don't tie the bars to a palette role in CSS (they used to read `background: $warning`): "warning" means cyan in one theme and yellow in the next, so the bar changed color for reasons that had nothing to do with chrome. `MenuLabel`'s hover and `-active` states derive from those two variables — a 15% tint of the bar's own text color, and a full reverse — so they stay legible on any palette.
 
 **Text selection colors:** selected text in the commit message box (Shift+arrows in the `TextArea`) is painted from `UITheme.text_selection_background` / `text_selection_foreground`, which `css_variables()` emits as Textual's own `$input-selection-background` / `$input-selection-foreground` — the variables `TextArea` and `Input` already read, so there is no selection CSS in the app. Unlike the chrome fields these are optional: an empty value emits nothing and leaves Textual's derived default (`$primary` lightened, at 40% over the background), because that default is fine in most themes and can't be written as a `$ref` `_resolve_refs()` understands. It is not fine in midnight-commander, where primary and background are both blue and a selection all but vanished; that theme sets `$warning` / `$background`, mcedit's dark-blue-on-cyan marked block. Set the selection through these fields, not through `variables`: `get_theme()` lets a `variables` entry win, so a second copy there would silently override the field.
 
-**Committing:** `action_commit_files()` asks twice, and the two questions are different. The first — only when a target still has unstaged changes — is `Stage N file(s) for commit?`, listing the `git add` commands that would run. The second always comes, after the message dialog: `_confirm_commit()` shows `Commit N file(s)?` over the commands from `GIT.commit_with_selection_commands()`, which is the last point at which the files going into the commit are visible before `commit_with_selection` walks the submodules and commits. The command list comes from that method rather than being rebuilt in `app.py` so the popup and the executor can't drift apart, and the message inside it is cut to `_commit_message_subject()` — its first line, marked with `TRUNCATION_MARKER` when there is more — because the popup renders one command per row and a multi-line `-m` argument would break that. N on it doesn't cancel: `_show_confirm()`'s `on_cancel` reopens the message editor — `CommitDialog`, or the external editor the settings name — on the message just written, so backing out of the confirmation costs nothing. That is the only reason `on_cancel` exists; every other caller wants the default, which hands focus back to the active view.
+**Committing:** `action_commit_files()` asks twice, and the two questions are different. The first — only when a target still has unstaged changes — is `Stage N file(s) for commit?`, listing the `git add` commands that would run. The second always comes, after the message dialog: `_confirm_commit()` shows `Commit N file(s)?` over the commands from `GIT.commit_with_selection_commands()`, which is the last point at which the files going into the commit are visible before `commit_with_selection` walks the submodules and commits. The command list comes from that method rather than being rebuilt in `app.py` so the popup and the executor can't drift apart, and the message inside it is cut to `_commit_message_subject()` — its first line, marked with `TRUNCATION_MARKER` when there is more — because the popup renders one command per row and a multi-line `-m` argument would break that. N on it doesn't cancel: `_show_confirm()`'s `on_cancel` reopens the message editor — `CommitDialog`, or the external editor the settings name — on the message just written, so backing out of the confirmation costs nothing. That and the startup submodule question (see *Starting inside a submodule*), whose N still has to start the app, are the only callers of `on_cancel`; every other caller wants the default, which hands focus back to the active view.
 
 Cancelling the message dialog rolls the index back to where the flow found it. Both halves of the mutation are undone: `_restore_externals()` re-stages the files it unstaged, and `_unstage_pending()` unstages what the stage confirmation added, from the `_pending_commit_staged` list `_begin_commit_message()` was handed. Without the second half the files stayed staged, so a second `C` on the same selection found nothing left to stage and skipped straight past `Stage N file(s) for commit?` — the question never came back. Only entries that had *nothing* staged before go on that list (`not code.has_staged_changes`): an entry that was already partly staged had its index state built by the user, and `git restore --staged` would throw that away instead of putting it back. `_commit_submit()` clears the list without running it — the files it staged are the files it just committed.
 

{gitnc-0.1.2 → gitnc-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gitnc
-Version: 0.1.2
+Version: 0.1.3
 Summary: GitNightCommander — a TUI git log browser built with Textual
 Project-URL: Homepage, https://github.com/thomashyldgaard/GitNightCommander
 Project-URL: Source, https://github.com/thomashyldgaard/GitNightCommander

{gitnc-0.1.2 → gitnc-0.1.3}/README.md

@@ -10,7 +10,9 @@ Main features:
 
 - **Easy handling of commits in projects that use git submodules** — staging
   and committing walk the submodules for you, and pull/push warn when a
-  submodule sits on a branch of its own.
+  submodule sits on a branch of its own. Started inside a submodule — at any
+  depth of nesting — the app offers to open the top-level repository instead
+  (`Y` / `N`).
 - **`Ctrl+O` switches to the command line** — drops the app to a `$SHELL` in
   the same terminal; press `Ctrl+O` again to switch back with the TUI right
   where you left it. Started from Midnight Commander's command line, mc keeps

{gitnc-0.1.2 → gitnc-0.1.3}/gitnc/app.py

@@ -132,6 +132,9 @@ MIDNIGHT_COMMANDER_WARNING = (
 )
 # Wide enough for the warning to wrap into a few readable lines.
 MIDNIGHT_COMMANDER_DIALOG_WIDTH = 60
+# Asked at startup when the repository is a submodule, however deeply nested:
+# the question is always about the outermost repository.
+SUPERPROJECT_PROMPT = "This repository is a submodule. Start in the top-level repository?"
 
 # Where the commit message is written: the app's own dialog, the editor named
 # by $EDITOR, or a command line typed into Options -> Settings. The last two
@@ -2804,10 +2807,48 @@ class GitNightCommanderApp(App):
 
     def on_mount(self) -> None:
         self._load_saved_theme()
+        self._offer_top_level_repository(then=self._start)
+
+    def _start(self) -> None:
         self._load_status()
         self._load_commits()
         self._warn_if_started_from_midnight_commander()
 
+    def _offer_top_level_repository(self, then: Callable[[], None]) -> None:
+        """Ask to move to the outermost superproject when started in a submodule.
+
+        Runs *then* once the question is answered (or at once, when there is
+        nothing to ask), so the first `git status` reads the repository the
+        user settled on rather than one it is about to leave. The chain is a
+        `git rev-parse` per nesting level, which doesn't grow with the repo,
+        so it runs inline.
+        """
+        chain = self.git.repository_chain()
+        if len(chain) < 2:
+            then()
+            return
+        rows = [f"submodule  {path}" for path in chain[:-1]]
+        rows.append(f"top-level  {chain[-1]}")
+
+        def confirmed() -> None:
+            self._switch_repository(chain[-1])
+            then()
+
+        self._show_confirm(SUPERPROJECT_PROMPT, rows, on_confirm=confirmed, on_cancel=then)
+
+    def _switch_repository(self, path: str) -> None:
+        """Point the app at *path*; the caller reloads the views.
+
+        The process moves there too, so the `Ctrl+O` shell and the tools run
+        from the previous screen start where the file list is.
+        """
+        self.repo_path = path
+        self.git = GIT(path)
+        try:
+            os.chdir(path)
+        except OSError:
+            pass
+
     def _warn_if_started_from_midnight_commander(self) -> None:
         if not started_from_midnight_commander():
             return

{gitnc-0.1.2 → gitnc-0.1.3}/gitnc/git.py

@@ -705,6 +705,28 @@ class GIT:
         name = (result.stdout or "").strip()
         return name or None
 
+    def repository_chain(self) -> list[str]:
+        """Return the working trees from this repository out to the top-level one.
+
+        The first entry is this repository's own top level, and each one after
+        it is the superproject the previous one is a submodule of, so the last
+        is the repository nothing contains. A repository that isn't a submodule
+        yields a single entry; a path outside any repository yields none.
+        """
+        result = self._run("rev-parse", "--show-toplevel")
+        toplevel = (result.stdout or "").strip()
+        if result.returncode != 0 or not toplevel:
+            return []
+        chain = [toplevel]
+        while True:
+            result = self._run_in(chain[-1], "rev-parse", "--show-superproject-working-tree")
+            parent = (result.stdout or "").strip()
+            # The membership check stops a misconfigured gitlink that points
+            # back into the chain from walking in circles.
+            if result.returncode != 0 or not parent or parent in chain:
+                return chain
+            chain.append(parent)
+
     def _branch_name_in(self, cwd: str) -> str | None:
         result = self._run_in(cwd, "branch", "--show-current")
         name = (result.stdout or "").strip()

{gitnc-0.1.2 → gitnc-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gitnc"
-version = "0.1.2"
+version = "0.1.3"
 description = "GitNightCommander — a TUI git log browser built with Textual"
 requires-python = ">=3.12"
 dependencies = [

{gitnc-0.1.2 → gitnc-0.1.3}/tests/test_app.py

@@ -630,6 +630,92 @@ class TestGitNightCommanderApp(unittest.TestCase):
 
         _DialogProbe(app).assert_not_shown()
 
+    def test_on_mount_does_not_ask_outside_a_submodule(self):
+        app = _mock_app()
+        app._load_status = MagicMock()
+
+        with (
+            patch.object(app, "_load_saved_theme"),
+            patch.object(_app_module, "started_from_midnight_commander", return_value=False),
+        ):
+            app.on_mount()
+
+        _DialogProbe(app).assert_not_shown()
+        app._load_status.assert_called_once_with()
+
+    def test_on_mount_offers_the_outermost_superproject(self):
+        app = _mock_app()
+        app._load_status = MagicMock()
+        app.git.repository_chain.return_value = ["/top/mid/sub", "/top/mid", "/top"]
+
+        with (
+            patch.object(app, "_load_saved_theme"),
+            patch.object(_app_module, "started_from_midnight_commander", return_value=False),
+        ):
+            app.on_mount()
+
+        _DialogProbe(app).assert_confirm(
+            _app_module.SUPERPROJECT_PROMPT,
+            ["submodule  /top/mid/sub", "submodule  /top/mid", "top-level  /top"],
+        )
+        # Nothing is read until the user has picked the repository.
+        app._load_status.assert_not_called()
+
+    def test_superproject_confirm_switches_to_the_top_level_repository(self):
+        app = _mock_app()
+        app._load_status = MagicMock()
+        app.git.repository_chain.return_value = ["/top/sub", "/top"]
+
+        with (
+            patch.object(app, "_load_saved_theme"),
+            patch.object(_app_module, "started_from_midnight_commander", return_value=False),
+        ):
+            app.on_mount()
+        with (
+            patch.object(_app_module, "GIT") as git_class,
+            patch.object(_app_module.os, "chdir") as chdir,
+        ):
+            _DialogProbe(app).confirm()
+
+        self.assertEqual(app.repo_path, "/top")
+        git_class.assert_called_once_with("/top")
+        self.assertIs(app.git, git_class.return_value)
+        chdir.assert_called_once_with("/top")
+        app._load_status.assert_called_once_with()
+
+    def test_superproject_cancel_stays_in_the_submodule(self):
+        app = _mock_app()
+        app._load_status = MagicMock()
+        app.git.repository_chain.return_value = ["/top/sub", "/top"]
+        git = app.git
+
+        with (
+            patch.object(app, "_load_saved_theme"),
+            patch.object(_app_module, "started_from_midnight_commander", return_value=False),
+        ):
+            app.on_mount()
+        with patch.object(_app_module.os, "chdir") as chdir:
+            _DialogProbe(app).cancel()
+
+        self.assertIs(app.git, git)
+        self.assertEqual(app.repo_path, ".")
+        chdir.assert_not_called()
+        app._load_status.assert_called_once_with()
+
+    def test_midnight_commander_warning_follows_the_superproject_question(self):
+        app = _mock_app()
+        app.git.repository_chain.return_value = ["/top/sub", "/top"]
+
+        with (
+            patch.object(app, "_load_saved_theme"),
+            patch.object(_app_module, "started_from_midnight_commander", return_value=True),
+        ):
+            app.on_mount()
+            self.assertIsInstance(_DialogProbe(app).assert_open(), _app_module.ConfirmDialog)
+            _DialogProbe(app).cancel()
+
+        self.assertIsInstance(_DialogProbe(app).pushed[-1], _app_module.MidnightCommanderDialog)
+
     def test_midnight_commander_dialog_keys(self):
         dialog_class = _app_module.MidnightCommanderDialog
         for key, expected in (("c", True), ("enter", True), ("e", False), ("escape", False)):
@@ -852,6 +938,8 @@ def _mock_app() -> Any:
     app.git = MagicMock()
     app.git.load_status.return_value = GitFilelist()
     app.git.load_commits.return_value = []
+    # Not a submodule, so on_mount goes straight to the first load.
+    app.git.repository_chain.return_value = ["/repo"]
     # Route entry-aware methods through the legacy filename-keyed mocks so
     # assertions on stage_file / unstage_file / stage_command / commit / etc.
     # keep working without per-test rewires. Submodule-specific behaviour is

{gitnc-0.1.2 → gitnc-0.1.3}/tests/test_git.py

@@ -734,6 +734,48 @@ class TestShutdown(unittest.TestCase):
         self.assertEqual(result.stdout, "")
 
 
+class TestRepositoryChain(unittest.TestCase):
+    """`GIT.repository_chain()`: this repo's top level out to the outermost superproject."""
+
+    def test_not_a_submodule_is_a_chain_of_one(self):
+        git = GIT("/top/src")
+        with fake_git_processes(results=[(0, "/top\n", ""), (0, "", "")]) as processes:
+            self.assertEqual(git.repository_chain(), ["/top"])
+
+        self.assertEqual(
+            processes.commands[1][-3:], ["/top", "rev-parse", "--show-superproject-working-tree"]
+        )
+
+    def test_nested_submodules_walk_out_to_the_top_level(self):
+        git = GIT("/top/mid/sub/src")
+        results = [
+            (0, "/top/mid/sub\n", ""),
+            (0, "/top/mid\n", ""),
+            (0, "/top\n", ""),
+            (0, "", ""),
+        ]
+        with fake_git_processes(results=results) as processes:
+            chain = git.repository_chain()
+
+        self.assertEqual(chain, ["/top/mid/sub", "/top/mid", "/top"])
+        # Each step asks from the repository the previous step found.
+        self.assertEqual(
+            [argv[4] for argv in processes.commands[1:]], ["/top/mid/sub", "/top/mid", "/top"]
+        )
+
+    def test_outside_a_repository_is_empty(self):
+        git = GIT("/tmp")
+        with fake_git_processes(returncode=128, stderr="fatal: not a git repository") as processes:
+            self.assertEqual(git.repository_chain(), [])
+
+        self.assertEqual(processes.call_count, 1)
+
+    def test_a_cycle_stops_the_walk(self):
+        git = GIT("/a")
+        with fake_git_processes(results=[(0, "/a\n", ""), (0, "/b\n", ""), (0, "/a\n", "")]):
+            self.assertEqual(git.repository_chain(), ["/a", "/b"])
+
+
 class TestRemoteCommands(unittest.TestCase):
     """git pull / push: upstream detection and the argv it produces."""