gitnc 0.1.4__tar.gz → 0.1.6__tar.gz

{gitnc-0.1.4 → gitnc-0.1.6}/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. It says so *beside* the help rather than in place of it: a pattern is invalid for most of the time it takes to type one (`[` already is), which is when the example is being read, and the help is two fixed lines so the dialog doesn't change height as the pattern passes in and out of compiling. 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.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gitnc
-Version: 0.1.4
+Version: 0.1.6
 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.6}/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.6}/gitnc/app.py

@@ -728,14 +728,29 @@ def _strip_markup(text: str) -> str:
     return re.sub(r"\[/?[^\[\]]*\]", "", text)
 
 
+# A zero-width space: takes no cell on screen, and is enough to stop a
+# backslash from escaping the tag that follows it. See `_escape_markup()`.
+MARKUP_BACKSLASH_GUARD = "\u200b"
+
+
 def _escape_markup(text: str) -> str:
     """`text` rendered literally, i.e. with its markup tags neutralised.
 
     Settings values are typed by the user and drawn into a markup-rendering
     Static, so a prompt template mentioning "[files]" would otherwise be read
     as a style tag and swallowed.
+
+    A backslash at the end gets `MARKUP_BACKSLASH_GUARD` after it: whatever
+    the caller puts next is usually a tag — the caret's, a closing one — and
+    a "[" behind a backslash is never read as a tag, so the value's last
+    character would otherwise escape the caller's markup. Textual has no
+    escape for the backslash itself, hence a separator rather than a second
+    backslash.
     """
-    return text.replace("[", "\\[")
+    escaped = text.replace("[", "\\[")
+    if escaped.endswith("\\"):
+        escaped += MARKUP_BACKSLASH_GUARD
+    return escaped
 
 
 # One word of a settings field plus the spaces that follow it, or a run of
@@ -831,6 +846,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 +948,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 +959,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] = {
@@ -957,6 +993,8 @@ SETTINGS_FIELD_MAX_LINES = 8
 # field, which is the widest thing the dialog draws (its four-cell indent
 # plus the frame's two borders).
 SETTINGS_SECTION_WIDTH = 4 + SETTINGS_FIELD_WIDTH + 2
+# Shown beside the required-prefix help while the pattern doesn't compile.
+PREFIX_PATTERN_INVALID = "not a valid regular expression"
 
 
 def _dialog_theme(screen: ModalScreen) -> UITheme:
@@ -1303,6 +1341,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 +1362,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 +1590,10 @@ 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.extend(self._prefix_pattern_hint())
         lines.append("")
         lines.append(self._section_header("Commit message editor"))
         lines.append("")
@@ -1595,6 +1640,29 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
             # values are already recorded, so there is simply nothing to paint.
             pass
 
+    def _prefix_pattern_hint(self) -> list[str]:
+        """The lines under the required-prefix row: what goes in it, and —
+        added to that rather than put in its place — that what is in it won't
+        compile, said here, while it is being typed, rather than first at the
+        next commit.
+
+        The help stays because a pattern is invalid for most of the time it
+        takes to type one ("[" already is), which is exactly when the example
+        is being read. It is two fixed lines for the same reason: left to
+        wrap, the dialog grew and shrank a row as the pattern passed in and
+        out of compiling.
+        """
+        theme = _dialog_theme(self)
+        hint = theme.dialog_hint
+        example = _escape_markup(r"[A-Z]+-\d+:")
+        invalid = ""
+        if not _is_valid_pattern(self._prefix_require_pattern):
+            invalid = f" [{theme.warning_text}]{PREFIX_PATTERN_INVALID}[/{theme.warning_text}]"
+        return [
+            f"[{hint}]    (optional regular expression for the start of the message,[/{hint}]",
+            f"[{hint}]     e.g. {example})[/{hint}]{invalid}",
+        ]
+
     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 +1696,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 +4120,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 +4404,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 +4453,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 +4744,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 +4763,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.6}/pyproject.toml

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

{gitnc-0.1.4 → gitnc-0.1.6}/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,64 @@ 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):
+        invalid = _app_module.PREFIX_PATTERN_INVALID
+        for pattern in ("", "[A-Z]+:"):
+            hint = "\n".join(SettingsDialog(prefix_require_pattern=pattern)._prefix_pattern_hint())
+            self.assertIn("optional", hint)
+            self.assertNotIn(invalid, hint)
+        self.assertIn(
+            invalid, "\n".join(SettingsDialog(prefix_require_pattern="[A-Z")._prefix_pattern_hint())
+        )
+
+    def test_the_required_prefix_pattern_help_stays_while_the_pattern_is_invalid(self):
+        """A pattern starting with "[" doesn't compile until its "]" is typed,
+        and the example used to be replaced by the complaint for all of that
+        time — the help went away just as it was being followed."""
+        valid = SettingsDialog()._prefix_pattern_hint()
+        invalid = SettingsDialog(prefix_require_pattern="[")._prefix_pattern_hint()
+
+        # Same number of rows either way, so the dialog doesn't change height.
+        self.assertEqual(len(invalid), len(valid))
+        self.assertEqual(invalid[:-1], valid[:-1])
+        self.assertTrue(invalid[-1].startswith(valid[-1]))
+        for line in invalid:
+            self.assertLessEqual(
+                len(_app_module._strip_markup(line.replace("\\[", ""))),
+                _app_module.SETTINGS_SECTION_WIDTH,
+            )
+
+    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()
 
@@ -3667,6 +3727,30 @@ class TestSettingsDialog(unittest.TestCase):
         dialog.on_key(_key_event("d", character="d"))
         self.assertEqual(dialog.get_values().draft_prompt, "abdc")
 
+    def test_a_backslash_does_not_escape_the_tag_that_follows_it(self):
+        """A regex ends in a backslash halfway through typing `\\d`, and the
+        caret's tag comes right after it: unguarded, the backslash escaped
+        that tag and its closing half had nothing to close — a MarkupError
+        that took the app down on the keypress."""
+        escape = _app_module._escape_markup
+        guard = _app_module.MARKUP_BACKSLASH_GUARD
+
+        self.assertEqual(escape("[A-Z]+-\\"), f"\\[A-Z]+-\\{guard}")
+        # Only the end needs it: inside the value the next character is text.
+        self.assertEqual(escape("\\d+:"), "\\d+:")
+        for value, column in (("\\", 1), ("\\", 0), ("a\\b", 1), ("a\\b\\", 4)):
+            markup = _app_module._caret_markup(value, column=column, style="reverse")
+            self.assertNotIn("\\[", markup)
+            try:
+                from textual.content import Content
+            except ImportError:
+                continue
+            # The real parser, when it is installed: the tags are read as
+            # tags, and the guard costs no cell.
+            content = Content.from_markup(markup)
+            self.assertEqual(content.plain.replace(guard, ""), value.ljust(column + 1))
+            self.assertEqual(content.cell_length, max(len(value), column + 1))
+
     def test_backspace_takes_the_character_in_front_of_the_caret(self):
         dialog = SettingsDialog(draft_prompt="abc")
         self._focus_prompt(dialog)
@@ -5324,6 +5408,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."""