gitnc 0.1.4__tar.gz → 0.1.5__tar.gz

{gitnc-0.1.4 → gitnc-0.1.5}/CLAUDE.md

@@ -62,6 +62,8 @@ Menu chrome is composed once and stays mounted, so `action_set_theme` / `_load_s
 
 A message prefixed with a branch the settings warn against gets a question of its own first: `_commit_result()` goes through `_confirm_commit_prefix()`, which — when the message starts with `<name>:` for a name in the `commit_prefix_warn_branches` setting — asks `Warning: commit message is prefixed with branch '…'. Continue?` over the message's subject line, and only on Y moves on to `Commit N file(s)?`. N reopens the message, the same way back the commit confirmation offers. It is a separate dialog rather than a row under the commands because a row only has to be overlooked. The setting is the *Warn on prefix* text row under the branch-prefix checkbox, a space- or comma-separated list read by `_branch_names()`. The check is on the message rather than the checked-out branch, because the prefill is editable and the prefix can have been typed by hand, and it comes after the editor because that is where the message is final whichever editor wrote it. `_begin_commit_message()` raises the same text — both come from `_commit_prefix_warning()` — as a warning notification when the prefill it is about to open already carries a listed prefix, so the user hears about it before writing the message around it.
 
+The row under it, *Warn on prefix not matching* (`commit_prefix_require_pattern`), is the opposite check through the same two places: an optional regular expression the message has to *start with*. `_starts_with_pattern()` is `re.match`, which anchors at the start and stops where the pattern does, so the setting describes the prefix alone — no `^`, no trailing `.*`. `_commit_prefix_warning()` collects both checks into one sentence (`… is prefixed with branch 'x' and does not start with a prefix matching '…'`), so a message that trips both is still asked about once. The pattern is quoted through `_escape_markup()`, because the confirm prompt and the toast both render markup and a character class would be read as a tag. A pattern that doesn't compile is reported as a warning of its own rather than skipped — a check that silently stopped checking looks exactly like a message that passed — and `SettingsDialog._prefix_pattern_hint()` says so under the row while it is being typed. Up front the pattern is only applied to a non-empty prefill: with the branch-prefix setting off nothing has been written yet, and the warning would fire on every commit.
+
 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.
 
 **Writing the message in an external editor:** the Options → Settings section *Commit message editor* is a three-row radio group — `SETTINGS_EDITOR_ROWS` maps each row to `COMMIT_EDITOR_BUILTIN` / `_ENVIRONMENT` / `_COMMAND`, Space picks one, and typing into the `Command:` row under it selects the command option — stored as `commit_editor` plus `commit_editor_command`. Every place the flow used to push `CommitDialog` for a message — `_begin_commit_message()` and the `on_cancel` of `_confirm_commit()` — now goes through `_edit_commit_message()`. That asks `_commit_editor_argv()` for a command line (`$EDITOR`, or the setting, split with `shlex`; `None` means the built-in dialog) and runs it with `_commit_in_external_editor()`: suspended on the previous screen like the drafting tool, with `run_commit_editor()` writing `commit_editor_template()` to a temporary `COMMIT_EDITMSG` (git's name, which is what puts editors in git-commit mode), running `<argv> <path>` and reading the file back through `strip_commit_editor_text()`. The help text and file list sit under git's scissors line (`COMMIT_EDITOR_SCISSORS`) rather than on `#` lines, so a message line starting with `#` survives. The result feeds `_commit_result()` exactly as the dialog's would: an empty message, one that is only the `branch:` prefix, or a failing exit status (`EditorResult.message is None`) cancels; anything else goes to the confirmation. Anything that stops the editor from running at all — unset `$EDITOR`, an empty or unparseable command, `EditorResult.started` false, a terminal that won't suspend — notifies and falls back to `CommitDialog`, so a bad setting never costs the user the commit. `KeyboardInterrupt` out of the editor is read as abandoning it, for the same reason as in the drafting tool. The Draft button lives in `CommitDialog`, so drafting isn't reachable with an external editor.

{gitnc-0.1.4 → gitnc-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gitnc
-Version: 0.1.4
+Version: 0.1.5
 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.4 → gitnc-0.1.5}/README.md

@@ -279,6 +279,13 @@ Options -> Settings configures the things it uses:
   `Commit N file(s)?` one: `Y` continues, `N` puts you back in the message to
   change it. When the branch prefix setting prefills such a name, the same
   warning also pops up as the message editor opens.
+- **Warn on prefix not matching** — optional; a regular expression the commit
+  message must start with (e.g. `[A-Z]+-\d+:` for a ticket number). It describes
+  the prefix only — it is matched at the start of the message, so no `^` and no
+  trailing `.*` are needed. A message that does not start with a match gets the
+  same confirmation and the same up-front warning as **Warn on prefix**; when
+  both settings object, the one question names both. A pattern that does not
+  compile is flagged in the settings dialog and reported in that question.
 - **Commit message editor** — where the message is written:
   - **Built-in editor** (the default) is the commit dialog described above.
   - **$EDITOR** runs the editor named by the `EDITOR` environment variable;

{gitnc-0.1.4 → gitnc-0.1.5}/gitnc/app.py

@@ -831,6 +831,25 @@ def _warned_commit_prefix(message: str, branches: Iterable[str]) -> str:
     return next((branch for branch in branches if message.startswith(f"{branch}:")), "")
 
 
+def _is_valid_pattern(pattern: str) -> bool:
+    """Whether `pattern` compiles as a regular expression."""
+    try:
+        re.compile(pattern)
+    except re.error:
+        return False
+    return True
+
+
+def _starts_with_pattern(message: str, pattern: str) -> bool:
+    """Whether `message` starts with something `pattern` matches.
+
+    `re.match` anchors at the start and stops where the pattern does, so the
+    setting describes the prefix alone — no `^` in front, and no `.*` behind
+    it for the rest of the message.
+    """
+    return re.match(pattern, message) is not None
+
+
 def _setting_str(settings: Mapping[str, object], key: str, default: str) -> str:
     """`settings[key]` when it holds a string, else `default`.
 
@@ -914,6 +933,7 @@ class SettingsValues(NamedTuple):
     editor: str = COMMIT_EDITOR_BUILTIN
     editor_command: str = ""
     prefix_warn_branches: str = ""
+    prefix_require_pattern: str = ""
 
 
 # Rows of the settings dialog, in the order they are drawn. The checkbox rows
@@ -924,14 +944,15 @@ class SettingsValues(NamedTuple):
 SETTINGS_ROW_BRANCH = 0
 SETTINGS_ROW_PREFIX = 1
 SETTINGS_ROW_PREFIX_WARN = 2
-SETTINGS_ROW_EDITOR_BUILTIN = 3
-SETTINGS_ROW_EDITOR_ENVIRONMENT = 4
-SETTINGS_ROW_EDITOR_COMMAND = 5
-SETTINGS_ROW_EDITOR_COMMAND_LINE = 6
-SETTINGS_ROW_COMMAND = 7
-SETTINGS_ROW_PROMPT = 8
-SETTINGS_ROW_PARSE = 9
-SETTINGS_ROW_COUNT = 10
+SETTINGS_ROW_PREFIX_PATTERN = 3
+SETTINGS_ROW_EDITOR_BUILTIN = 4
+SETTINGS_ROW_EDITOR_ENVIRONMENT = 5
+SETTINGS_ROW_EDITOR_COMMAND = 6
+SETTINGS_ROW_EDITOR_COMMAND_LINE = 7
+SETTINGS_ROW_COMMAND = 8
+SETTINGS_ROW_PROMPT = 9
+SETTINGS_ROW_PARSE = 10
+SETTINGS_ROW_COUNT = 11
 
 # Which editor each radio row selects.
 SETTINGS_EDITOR_ROWS: dict[int, str] = {
@@ -1303,6 +1324,7 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
     TEXT_ROWS: ClassVar[dict[int, str]] = {
         SETTINGS_ROW_BRANCH: "_default_branch",
         SETTINGS_ROW_PREFIX_WARN: "_prefix_warn_branches",
+        SETTINGS_ROW_PREFIX_PATTERN: "_prefix_require_pattern",
         SETTINGS_ROW_EDITOR_COMMAND_LINE: "_editor_command",
         SETTINGS_ROW_COMMAND: "_draft_command",
         SETTINGS_ROW_PROMPT: "_draft_prompt",
@@ -1323,12 +1345,14 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
         editor: str = COMMIT_EDITOR_BUILTIN,
         editor_command: str = "",
         prefix_warn_branches: str = "",
+        prefix_require_pattern: str = "",
     ) -> None:
         super().__init__()
         self._cursor: int = 0
         self._default_branch: str = default_branch
         self._branch_prefix: bool = branch_prefix
         self._prefix_warn_branches: str = prefix_warn_branches
+        self._prefix_require_pattern: str = prefix_require_pattern
         self._draft_command: str = draft_command
         self._draft_prompt: str = draft_prompt
         self._parse_suggestions: bool = parse_suggestions
@@ -1549,6 +1573,12 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
             "    (branch names, separated by spaces, e.g. master main)"
             f"[/{theme.dialog_hint}]"
         )
+        lines.append(
+            self._text_row(SETTINGS_ROW_PREFIX_PATTERN, "      Warn on prefix not matching: ")
+        )
+        lines.append(
+            f"[{theme.dialog_hint}]    ({self._prefix_pattern_hint()})[/{theme.dialog_hint}]"
+        )
         lines.append("")
         lines.append(self._section_header("Commit message editor"))
         lines.append("")
@@ -1595,6 +1625,15 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
             # values are already recorded, so there is simply nothing to paint.
             pass
 
+    def _prefix_pattern_hint(self) -> str:
+        """The line under the required-prefix row: what goes in it, or that
+        what is in it won't compile — said here, while it is being typed,
+        rather than first at the next commit."""
+        if not _is_valid_pattern(self._prefix_require_pattern):
+            return "not a valid regular expression"
+        example = _escape_markup(r"[A-Z]+-\d+:")
+        return f"optional regular expression for the start of the message, e.g. {example}"
+
     def _key_hint(self) -> str:
         """The key line under the dialog, which is not the same in a framed
         field: the arrows belong to the caret there, and Tab is what leaves."""
@@ -1628,6 +1667,7 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
             editor=self._editor,
             editor_command=self._editor_command,
             prefix_warn_branches=self._prefix_warn_branches,
+            prefix_require_pattern=self._prefix_require_pattern,
         )
 
 
@@ -4051,7 +4091,9 @@ class GitNightCommanderApp(App):
         self._pending_commit_targets = list(targets)
         branch = self._commit_branch_prefix()
         prefill = f"{branch}: " if branch else ""
-        warning = self._commit_prefix_warning(prefill)
+        # Only a prefill is checked: with nothing written yet there is no
+        # prefix to judge, and the required pattern would fail every time.
+        warning = self._commit_prefix_warning(prefill) if prefill else ""
         if warning:
             # Up front as well as in the question asked after the message:
             # the prefix is already known here, and this is before the
@@ -4333,8 +4375,9 @@ class GitNightCommanderApp(App):
             self._confirm_commit_prefix(message)
 
     def _confirm_commit_prefix(self, message: str) -> None:
-        """Ask about a branch prefix the settings warn against, before the
-        commit confirmation rather than as a row inside it.
+        """Ask about a prefix the settings warn against — a listed branch,
+        or one the required pattern doesn't match — before the commit
+        confirmation rather than as a row inside it.
 
         A question of its own has to be answered; a row under a list of
         commands only has to be overlooked. It comes here rather than on the
@@ -4381,19 +4424,35 @@ class GitNightCommanderApp(App):
         )
 
     def _commit_prefix_warning(self, message: str) -> str:
-        """The warning for a message prefixed with a branch named in the
-        `commit_prefix_warn_branches` setting, or "" when it isn't.
+        """The warning for a message whose prefix the settings object to, or
+        "" when they don't: it starts with a branch named in
+        `commit_prefix_warn_branches`, or it doesn't start with what the
+        `commit_prefix_require_pattern` regular expression asks for. Both
+        are reported when both apply.
 
         One text for the notification the message editor opens with and the
         question asked once the message is written, so the two can't drift.
+        The pattern is quoted with its brackets escaped, because both of
+        those render markup and a character class would be read as a tag.
         """
-        branches = _branch_names(
-            _setting_str(self._load_settings(), "commit_prefix_warn_branches", "")
-        )
+        settings = self._load_settings()
+        problems: list[str] = []
+        branches = _branch_names(_setting_str(settings, "commit_prefix_warn_branches", ""))
         branch = _warned_commit_prefix(message, branches)
-        if not branch:
+        if branch:
+            problems.append(f"is prefixed with branch '{branch}'")
+        pattern = _setting_str(settings, "commit_prefix_require_pattern", "")
+        if pattern.strip():
+            quoted = _escape_markup(pattern)
+            if not _is_valid_pattern(pattern):
+                # Said rather than skipped: a check that silently stopped
+                # checking would look exactly like a message that passed.
+                problems.append(f"can't be checked against invalid pattern '{quoted}'")
+            elif not _starts_with_pattern(message, pattern):
+                problems.append(f"does not start with a prefix matching '{quoted}'")
+        if not problems:
             return ""
-        return f"Warning: commit message is prefixed with branch '{branch}'"
+        return f"Warning: commit message {' and '.join(problems)}"
 
     def _commit_submit(self, message: str) -> None:
         result = self.git.commit_with_selection(self._pending_commit_targets, message)
@@ -4656,6 +4715,7 @@ class GitNightCommanderApp(App):
                 editor=_setting_str(settings, "commit_editor", COMMIT_EDITOR_BUILTIN),
                 editor_command=_setting_str(settings, "commit_editor_command", ""),
                 prefix_warn_branches=_setting_str(settings, "commit_prefix_warn_branches", ""),
+                prefix_require_pattern=_setting_str(settings, "commit_prefix_require_pattern", ""),
             ),
             callback=self._settings_result,
         )
@@ -4674,6 +4734,7 @@ class GitNightCommanderApp(App):
         settings["commit_editor"] = values.editor
         settings["commit_editor_command"] = values.editor_command
         settings["commit_prefix_warn_branches"] = values.prefix_warn_branches
+        settings["commit_prefix_require_pattern"] = values.prefix_require_pattern
         if not self._save_settings(settings):
             self.notify("Settings saved (could not write to disk)")
         else:

{gitnc-0.1.4 → gitnc-0.1.5}/pyproject.toml

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

{gitnc-0.1.4 → gitnc-0.1.5}/tests/test_app.py

@@ -346,6 +346,7 @@ try:
         SETTINGS_ROW_EDITOR_COMMAND_LINE,
         SETTINGS_ROW_EDITOR_ENVIRONMENT,
         SETTINGS_ROW_PARSE,
+        SETTINGS_ROW_PREFIX_PATTERN,
         SETTINGS_ROW_PREFIX_WARN,
         SETTINGS_ROW_PROMPT,
         SETTINGS_SECTION_WIDTH,
@@ -442,6 +443,7 @@ except ModuleNotFoundError as exc:
         SETTINGS_ROW_EDITOR_COMMAND_LINE,
         SETTINGS_ROW_EDITOR_ENVIRONMENT,
         SETTINGS_ROW_PARSE,
+        SETTINGS_ROW_PREFIX_PATTERN,
         SETTINGS_ROW_PREFIX_WARN,
         SETTINGS_ROW_PROMPT,
         SETTINGS_SECTION_WIDTH,
@@ -3426,6 +3428,47 @@ class TestSettingsDialog(unittest.TestCase):
 
         self.assertEqual(saved["commit_prefix_warn_branches"], "master main")
 
+    def test_the_required_prefix_pattern_is_typed_under_the_warned_prefixes(self):
+        dialog = SettingsDialog(prefix_require_pattern="[A-Z]+")
+        for _ in range(SETTINGS_ROW_PREFIX_PATTERN):
+            dialog.on_key(_key_event("down"))
+        self.assertEqual(dialog._cursor, SETTINGS_ROW_PREFIX_PATTERN)
+        self.assertEqual(SETTINGS_ROW_PREFIX_PATTERN, SETTINGS_ROW_PREFIX_WARN + 1)
+
+        for key, character in (("minus", "-"), ("1", "1")):
+            dialog.on_key(_key_event(key, character=character))
+
+        self.assertEqual(dialog.get_values().prefix_require_pattern, "[A-Z]+-1")
+        self.assertEqual(dialog.get_values().prefix_warn_branches, "")
+
+    def test_the_required_prefix_pattern_hint_says_when_it_does_not_compile(self):
+        self.assertIn("optional", SettingsDialog()._prefix_pattern_hint())
+        self.assertIn(
+            "optional", SettingsDialog(prefix_require_pattern="[A-Z]+:")._prefix_pattern_hint()
+        )
+        self.assertEqual(
+            SettingsDialog(prefix_require_pattern="[A-Z")._prefix_pattern_hint(),
+            "not a valid regular expression",
+        )
+
+    def test_the_required_prefix_pattern_round_trips_through_the_settings_file(self):
+        app = _mock_app()
+        with patch.object(
+            app, "_load_settings", return_value={"commit_prefix_require_pattern": r"[A-Z]+-\d+:"}
+        ):
+            app.action_settings()
+        values = _pushed_screen(app).get_values()
+        self.assertEqual(values.prefix_require_pattern, r"[A-Z]+-\d+:")
+
+        saved: dict[str, object] = {}
+        with (
+            patch.object(app, "_load_settings", return_value={}),
+            patch.object(app, "_save_settings", side_effect=lambda s: saved.update(s) or True),
+        ):
+            app._settings_result(values)
+
+        self.assertEqual(saved["commit_prefix_require_pattern"], r"[A-Z]+-\d+:")
+
     def test_cursor_wraps_over_every_row(self):
         dialog = SettingsDialog()
 
@@ -5324,6 +5367,119 @@ class TestCommitFlow(unittest.TestCase):
         self.assertEqual(self._commit_screen(dialogs).prefill, "feature: ")
         notify.assert_not_called()
 
+    def _pattern_app(self, pattern: str, **settings: Any):
+        entry = GitEntry(GitCode.MODIFIED_UNMODIFIED, "pkg/a.py")
+        app, dialogs, _ = self._app([entry], staged={"pkg/a.py"})
+        app._load_settings = MagicMock(
+            return_value={"commit_prefix_require_pattern": pattern, **settings}
+        )
+        app.action_commit_files()
+        return app, dialogs
+
+    def test_a_message_missing_the_required_prefix_is_asked_about(self):
+        app, dialogs = self._pattern_app(r"[A-Z]+-\d+:")
+
+        dialogs._resolve("fix x")
+
+        self.assertEqual(
+            dialogs.prompt(),
+            "Warning: commit message does not start with a prefix matching"
+            r" '\[A-Z]+-\d+:'. Continue?",
+        )
+        self.assertEqual(dialogs.commands(), ["fix x"])
+        app.git.commit.assert_not_called()
+
+    def test_declining_the_required_prefix_warning_reopens_the_message(self):
+        _, dialogs = self._pattern_app(r"\w+-\d+:")
+        dialogs._resolve("fix x")
+
+        dialogs.cancel()
+
+        reopened = dialogs.pushed[-1]
+        self.assertIsInstance(reopened, CommitDialog)
+        self.assertEqual(reopened.prefill, "fix x")
+
+    def test_the_required_pattern_covers_only_the_start_of_the_message(self):
+        """No `.*` needed for the rest of the message, and a match further
+        in doesn't count as a prefix."""
+        for message, accepted in (
+            ("ABC-12: fix x\n\nbody", True),
+            ("ABC-12:", True),
+            ("fix ABC-12: x", False),
+            ("\nABC-12: x", False),
+        ):
+            with self.subTest(message=message):
+                _, dialogs = self._pattern_app(r"[A-Z]+-\d+:")
+
+                dialogs._resolve(message)
+
+                self.assertEqual(dialogs.prompt() == "Commit 1 file(s)?", accepted)
+
+    def test_a_blank_required_pattern_checks_nothing(self):
+        _, dialogs = self._pattern_app("  ")
+
+        dialogs._resolve("fix x")
+
+        self.assertEqual(dialogs.prompt(), "Commit 1 file(s)?")
+
+    def test_an_invalid_required_pattern_is_reported_instead_of_skipped(self):
+        _, dialogs = self._pattern_app("[A-Z")
+
+        dialogs._resolve("fix x")
+
+        self.assertEqual(
+            dialogs.prompt(),
+            r"Warning: commit message can't be checked against invalid pattern '\[A-Z'."
+            " Continue?",
+        )
+
+    def test_a_warned_branch_and_a_missing_prefix_are_reported_together(self):
+        _, dialogs = self._pattern_app(r"\d+:", commit_prefix_warn_branches="master")
+
+        dialogs._resolve("master: fix x")
+
+        self.assertEqual(
+            dialogs.prompt(),
+            "Warning: commit message is prefixed with branch 'master'"
+            r" and does not start with a prefix matching '\d+:'. Continue?",
+        )
+
+    def test_a_prefill_missing_the_required_prefix_is_announced_up_front(self):
+        entry = GitEntry(GitCode.MODIFIED_UNMODIFIED, "pkg/a.py")
+        for branch, warned in (("feature", True), ("ABC-12", False)):
+            with self.subTest(branch=branch):
+                app, _, _ = self._app([entry], staged={"pkg/a.py"}, branch=branch)
+                app._load_settings = MagicMock(
+                    return_value={
+                        "branch_prefix_in_commits": True,
+                        "commit_prefix_require_pattern": r"[A-Z]+-\d+:",
+                    }
+                )
+
+                with patch.object(app, "notify") as notify:
+                    app.action_commit_files()
+
+                if warned:
+                    notify.assert_called_once_with(
+                        "Warning: commit message does not start with a prefix matching"
+                        r" '\[A-Z]+-\d+:'",
+                        severity="warning",
+                    )
+                else:
+                    notify.assert_not_called()
+
+    def test_an_empty_prefill_is_not_checked_against_the_required_pattern(self):
+        """Nothing has been written yet, so there is no prefix to judge."""
+        entry = GitEntry(GitCode.MODIFIED_UNMODIFIED, "pkg/a.py")
+        app, dialogs, _ = self._app([entry], staged={"pkg/a.py"})
+        app._load_settings = MagicMock(return_value={"commit_prefix_require_pattern": r"\d+:"})
+
+        with patch.object(app, "notify") as notify:
+            app.action_commit_files()
+
+        self.assertEqual(self._commit_screen(dialogs).prefill, "")
+        notify.assert_not_called()
+
     def test_other_prefixes_go_straight_to_the_commit_confirmation(self):
         """Only a whole listed name followed by the colon counts — not a
         branch that merely starts with one, and not the name mid-message."""