gitnc 0.1.5__tar.gz → 0.1.6__tar.gz

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

@@ -62,7 +62,7 @@ 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.
+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.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gitnc
-Version: 0.1.5
+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.5 → 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
@@ -978,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:
@@ -1576,9 +1593,7 @@ class SettingsDialog(ModalScreen["SettingsValues | None"]):
         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.extend(self._prefix_pattern_hint())
         lines.append("")
         lines.append(self._section_header("Commit message editor"))
         lines.append("")
@@ -1625,14 +1640,28 @@ 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"
+    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+:")
-        return f"optional regular expression for the start of the message, e.g. {example}"
+        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

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

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

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

@@ -3442,14 +3442,31 @@ class TestSettingsDialog(unittest.TestCase):
         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())
+        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(
-            "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",
-        )
+            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()
@@ -3710,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)