console-window 2.1.1__tar.gz → 2.1.2__tar.gz

{console_window-2.1.1 → console_window-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: console-window
-Version: 2.1.1
+Version: 2.1.2
 Summary: A robust curses wrapper for creating Text User Interfaces (TUIs).
 Author-email: Joe Defen <joedef@duck.com>
 Requires-Python: >=3.10

{console_window-2.1.1 → console_window-2.1.2}/console_window/__init__.py

@@ -1,6 +1,6 @@
 # Single source of truth for the package version: pyproject.toml declares
 # ``dynamic = ["version"]``, so flit reads this value instead of duplicating it.
-__version__ = "2.1.1"
+__version__ = "2.1.2"
 
 from .context import Context
 from .header import HeaderLine, Span

{console_window-2.1.1 → console_window-2.1.2}/console_window/textwidth.py

@@ -21,6 +21,14 @@ __all__ = [
 # characters (ZWJ, variation selectors, BOM, …) and control characters.
 _ZERO_WIDTH_CATEGORIES = frozenset({'Mn', 'Me', 'Cf', 'Cc'})
 
+# Variation selectors.  VS16 asks for *emoji* presentation, which terminals
+# draw two cells wide even when the base character's own East-Asian width is
+# Narrow/Ambiguous (U+26A0 WARNING SIGN, U+2714 HEAVY CHECK MARK, U+2139
+# INFORMATION SOURCE).  VS15 asks for text presentation and needs no
+# adjustment: such bases already count as one cell.
+_VS16 = '\ufe0f'
+_VS15 = '\ufe0e'  # no adjustment needed; named for symmetry with _VS16
+
 # Any character that is not printable ASCII needs per-character measurement.
 # Everything else is exactly one cell wide, so measurement can skip whole
 # ASCII runs in C and only visit the glyphs that actually differ.
@@ -51,6 +59,26 @@ def _non_ascii_char_width(ch: str) -> int:
     return 1
 
 
+def _string_char_width(text: str, index: int) -> int:
+    """Width of ``text[index]`` with variation selectors folded into the base.
+
+    ``char_width()`` stays per code point on purpose: the cursor helpers move
+    by code point and must never be able to land between a base and its
+    selector.  String-level measurement is where the one context-dependent
+    rule belongs -- a VS16 after a narrow, non-ASCII base makes that cluster
+    two cells wide, which is how terminals draw ``⚠️``.  A base that already
+    counts two cells (⌚ U+231A, ⌛ U+231B) keeps its width, and ASCII is left
+    alone because terminals do not double it.
+    """
+    ch = text[index]
+    if ch != _VS16 or index == 0:
+        return char_width(ch)
+    base = text[index - 1]
+    if base.isascii() or char_width(base) != 1:
+        return 0
+    return 1
+
+
 def char_width(ch: str) -> int:
     if not ch:
         return 0
@@ -70,7 +98,7 @@ def string_width(text: str) -> int:
     # without needing a whole-string cache large enough for every body row.
     width = len(text)
     for match in _SPECIAL_CHAR.finditer(text):
-        width += char_width(match.group()) - 1
+        width += _string_char_width(text, match.start()) - 1
     return width
 
 
@@ -92,7 +120,7 @@ def truncate(text: str, max_width: int) -> str:
         if total + run > max_width:
             return text[:ascii_start + max_width - total]
         total += run
-        w = char_width(match.group())
+        w = _string_char_width(text, match.start())
         if total + w > max_width:
             return text[:match.start()]
         total += w
@@ -125,7 +153,7 @@ def cell_to_index(text: str, col: int) -> int:
         if total + run > col:
             return ascii_start + col - total
         total += run
-        w = char_width(match.group())
+        w = _string_char_width(text, match.start())
         if total + w > col:
             return match.start()
         total += w

{console_window-2.1.1 → console_window-2.1.2}/console_window/widgets.py

@@ -333,15 +333,24 @@ class PromptLine:
     :class:`InlineConfirmation`; note that ``InlineConfirmation`` forces
     ``mode='choices'`` when ``choices`` is supplied -- that is intended, not a
     bug.  The caller's ``prompt`` text is used verbatim, so decorations such as
-    a warning glyph stay in application code rather than in the library.
+    a warning glyph stay in application code rather than in the library.  The
+    same goes for the trailing answer hint: pass *answer_hint* to replace the
+    default ``[Press "y" or ESC]`` wording, which lets an application bracket
+    the whole line with its own glyphs.
     """
 
+    #: Default trailing hint for the one-key confirmation modes.  ``{mode}`` is
+    #: replaced with the live mode letter, so ``'y'`` and ``'Y'`` both label
+    #: themselves without the caller tracking it.
+    DEFAULT_ANSWER_HINT = '[Press "{mode}" or ESC]'
+
     def __init__(self) -> None:
         self._editor = InlineConfirmation()
         #: Public state, mirrored from start() so a caller can inspect it.
         self.active: bool = False
         self.prompt: str = ''
         self.hint: str = ''
+        self.answer_hint: str = ''
         self._on_confirm: Callable[[str], object] | None = None
         self._on_cancel: Callable[[], object] | None = None
         self._answer: str | None = None
@@ -352,13 +361,15 @@ class PromptLine:
               choices: str | list[str] | tuple[str, ...] | None = None,
               on_confirm: Callable[[str], object] | None = None,
               on_cancel: Callable[[], object] | None = None,
-              min_abbrev_chars: int | None = None) -> None:
+              min_abbrev_chars: int | None = None,
+              answer_hint: str = '') -> None:
         self._editor.start(action_type=None, identity=identity, choices=choices,
                            mode=mode, min_abbrev_chars=min_abbrev_chars,
                            initial=seed)
         self.active = True
         self.prompt = prompt
         self.hint = hint
+        self.answer_hint = answer_hint
         self._on_confirm = on_confirm
         self._on_cancel = on_cancel
         self._answer = None
@@ -398,6 +409,7 @@ class PromptLine:
         self._editor.cancel()
         self.prompt = ''
         self.hint = ''
+        self.answer_hint = ''
         self._on_confirm = None
         self._on_cancel = None
         self._answer = None
@@ -409,7 +421,11 @@ class PromptLine:
             return ''
         mode = self._editor.mode or ''
         if mode in ('Y', 'y'):
-            return f'{self.prompt}  [Press "{mode}" or ESC]'
+            hint = self.answer_hint or self.DEFAULT_ANSWER_HINT
+            # replace() rather than format(): the template is caller text and
+            # may legitimately contain braces (``["y" or ESC] {⚠️}`` style
+            # decorations are not worth a formatting error at paint time).
+            return f'{self.prompt}  {hint.replace("{mode}", mode)}'
         buffer = self._editor.get_display_string('', cursor_char)
         return f'{self.prompt}: {buffer}'
 

{console_window-2.1.1 → console_window-2.1.2}/console_window/window.py

@@ -91,11 +91,39 @@ _NAV_HELP_PREFIX = 'Navigation:  '
 _NAV_APP_PREFIX = 'App:         '
 
 
-def _nav_key_label(key: int) -> str:
-    label = NAV_KEY_LABELS.get(key)
+# Every key curses knows, keyed by its integer code.  Deriving the table from
+# the module constants keeps terminal-specific keys (F-keys, shift-arrows,
+# keypad) covered without a hardcoded list.  KEY_MIN/KEY_MAX are range
+# sentinels rather than keys, and KEY_MIN aliases KEY_BREAK, so both are
+# skipped; the surviving alias names a real key.
+_CURSES_KEY_NAMES: dict[int, str] = {
+    getattr(curses, name): name.removeprefix('KEY_')
+    for name in dir(curses)
+    if name.startswith('KEY_') and name not in ('KEY_MIN', 'KEY_MAX')
+}
+
+
+def _key_label(key: int) -> str:
+    """Best human-readable name for a curses key code.
+
+    A ``curses.KEY_*`` name wins (``LEFT``, ``F5``, ``RESIZE``), then control
+    characters in caret notation (``^U``), then a printable character.  An
+    unknown code is shown as ``<code>`` rather than a bare ``???``, so a label
+    never hides *which* key arrived.
+    """
+    label = _CURSES_KEY_NAMES.get(key)
     if label is not None:
         return label
-    return chr(key) if 32 <= key < 127 else f'<{key}>'
+    if 0 <= key < 32:
+        return f'^{chr(key + 64)}'
+    if 32 <= key < 127:
+        return chr(key)
+    return f'<{key}>'
+
+
+def _nav_key_label(key: int) -> str:
+    label = NAV_KEY_LABELS.get(key)
+    return label if label is not None else _key_label(key)
 
 
 def _pair_nav_entries(entries: list[str], prefix: str) -> list[str]:
@@ -163,6 +191,22 @@ _PASSTHROUGH_EDITING_KEYS = frozenset({
     1, 5,  # Ctrl-A, Ctrl-E
 })
 
+# Compact demo-mode names for the keys whose plain curses name would be
+# unwieldy or ambiguous in the header indicator.  Printable keys are handled
+# separately (centred with spaces), so this table only covers the rest.
+_DEMO_KEY_LABELS: dict[int, str] = {
+    27: 'ESC',
+    ord('\t'): 'TAB',
+    10: 'ENT',  # newline
+    13: 'ENT',  # carriage return (KEY_ENTER on some terminals)
+    curses.KEY_ENTER: 'ENT',
+    ord(' '): 'SPC',
+    8: 'BSP',
+    127: 'BSP',
+    curses.KEY_BACKSPACE: 'BSP',
+    curses.KEY_DC: 'DEL',
+}
+
 # Live ConsoleWindow instances, held by weak reference and keyed by creation
 # order.  The registry keeps creation order (so ``primary_window()`` is
 # deterministic) and never keeps a window alive.  It serves both models:
@@ -502,6 +546,11 @@ class ConsoleWindow:
         # ends, so a callback can start the next prompt (see begin_prompt()).
         self.prompt_line = PromptLine()
         self._prompt_prev_passthrough = False
+        # Extra attribute for the separator rule while a prompt is live, so the
+        # chrome can recede behind the only interactive line on screen.  None
+        # (the default) leaves the rule undifferentiated.  This is app policy,
+        # like pick_attr: the window only decides *when* to apply it.
+        self.prompt_separator_attr: int | None = None
         # Transient status shown on the separator row (see status()).  Kept on
         # the window rather than a pad because the row belongs to the screen,
         # not to either pad (render_once() paints it directly on self.scr).
@@ -555,25 +604,14 @@ class ConsoleWindow:
         return self.opts.demo_mode
 
     def _format_key_for_demo(self, key: int) -> str:
-        # Special multi-character keys
-        if key == 27:  # ESC
-            return 'ESC'
-        elif key == ord('\t'):
-            return 'TAB'
-        elif key == ord('\n') or key == curses.KEY_ENTER or key == 10 or key == 13:
-            return 'ENT'
-        elif key == ord(' '):
-            return 'SPC'
-        elif key == curses.KEY_BACKSPACE or key == 127 or key == 8:
-            return 'BSP'
-        elif key == curses.KEY_DC:
-            return 'DEL'
+        label = _DEMO_KEY_LABELS.get(key)
+        if label is not None:
+            return label
         # Printable single character keys - center with spaces
-        elif 32 < key < 127:
+        if 32 < key < 127:
             return f' {chr(key)} '
-        # Default for unrecognized keys
-        else:
-            return '???'
+        # Named curses key, control character, or an explicit <code>
+        return _key_label(key)
 
     def get_pad_width(self) -> int:
         return min(self.cols-1, self.body_cols)
@@ -1153,17 +1191,24 @@ class ConsoleWindow:
                      identity: str | None = None, seed: str = '',
                      choices: str | list[str] | tuple[str, ...] | None = None,
                      on_confirm: Callable[[str], object] | None = None,
-                     on_cancel: Callable[[], object] | None = None) -> bool:
+                     on_cancel: Callable[[], object] | None = None,
+                     answer_hint: str = '') -> bool:
         """Start an in-place prompt and enable passthrough key routing.
 
         The window *is* the receiver, so there is no window-existence branch
         here; an application whose window may be ``None`` guards at its own
         call site.  Every key must then go through :meth:`handle_prompt_key`
         and a ``'continue'`` result must be swallowed.
+
+        *answer_hint* replaces the default trailing ``[Press "y" or ESC]`` text
+        for the one-key modes; ``{mode}`` in it is replaced with the live mode
+        letter.  Use it when the application wants its own bracketing or a
+        trailing decoration (see :class:`PromptLine`).
         """
         self.prompt_line.start(prompt, hint=hint, mode=mode, identity=identity,
                                seed=seed, choices=choices,
-                               on_confirm=on_confirm, on_cancel=on_cancel)
+                               on_confirm=on_confirm, on_cancel=on_cancel,
+                               answer_hint=answer_hint)
         self._prompt_prev_passthrough = self.passthrough_mode
         self.passthrough_mode = True
         return True
@@ -1195,12 +1240,30 @@ class ConsoleWindow:
             on_cancel()
         return result
 
-    def add_prompt_header(self, attr: int | None = None) -> bool:
-        """Draw the prompt as a header row; False when no prompt is active."""
+    def add_prompt_header(self, attr: int | None = None,
+                          align: str | None = None) -> bool:
+        """Draw the prompt as a header row; False when no prompt is active.
+
+        *align* of ``'center'`` pads the row so the prompt sits in the middle of
+        the usable width.  Centering is done here rather than by the caller
+        because the display width of the line is only known after the prompt is
+        composed (glyphs, an emoji presentation selector and the hint all
+        count), and a caller-side ``len()`` would be one cell out for exactly
+        the lines that need centering most.
+        """
         if not self.prompt_line.active:
             return False
-        self.add_header(self.prompt_line.get_display_string(),
-                        attr=attr if attr is not None else curses.A_BOLD)
+        text = self.prompt_line.get_display_string()
+        attr = attr if attr is not None else curses.A_BOLD
+        if align == 'center':
+            lead = max(0, (self.get_pad_width() - textwidth.string_width(text)) // 2)
+            if lead:
+                # Two adds on one row: the pad spaces carry the prompt's own
+                # attribute so the whole band, not just its text, is painted.
+                self.add_header(' ' * lead, attr=attr)
+                self.add_header(text, attr=attr, resume=True)
+                return True
+        self.add_header(text, attr=attr)
         return True
 
     def add_prompt_lines(self, attr: int | None = None,
@@ -1761,7 +1824,12 @@ class ConsoleWindow:
                 self.scr.addstr(pos, 0, '>', curses.A_REVERSE)
 
     def _draw_separator_and_indicator(self) -> None:
-        self.scr.hline(self.head.view_cnt, 0, curses.ACS_HLINE, self.cols)
+        # While an in-place prompt is live it is the only thing keys can reach,
+        # so an application may ask for the rule to recede behind it.
+        rule_attr = (self.prompt_separator_attr
+                     if self.prompt_line.active and self.prompt_separator_attr is not None
+                     else curses.A_NORMAL)
+        self.scr.hline(self.head.view_cnt, 0, curses.ACS_HLINE, self.cols, rule_attr)
         ind_pos = self._scroll_indicator_col()
         bot, cnt = self._scroll_indicator_span(ind_pos) if ind_pos >= 0 else (-1, 0)
         # Status first: it must not be able to cover the indicator, and it must

{console_window-2.1.1 → console_window-2.1.2}/tests/CHANGELOG.md

@@ -35,6 +35,11 @@ This project follows [Semantic Versioning](https://semver.org/).
   body rows without `Context` so normal navigation scrolls them.
 
 ### Changed
+- Demo-mode key labels no longer fall back to `???` for anything curses can
+  name: `curses.KEY_*` codes are rendered from the curses constant names (so a
+  taken `KEY_LEFT`/`KEY_RIGHT` shows `LEFT`/`RIGHT`, and F-keys, shift-arrows,
+  `HOME`, `RESIZE`, etc. show their own names), control characters use caret
+  notation (`^U`), and a code curses does not know is shown as `<code>`.
 - `SampleApp.py` now exercises the new API: `SPACE` uses the window prompt
   lifecycle with a `PromptLine` single-key confirmation, `N` adds a buffered
   header note prompt, non-modal feedback uses `status()`, and the HISTORY
@@ -98,6 +103,17 @@ This project follows [Semantic Versioning](https://semver.org/).
   into every span of the header (including plain spans and the raw line emitted
   for `mode='Off'`), so a caller can dim a whole fancy header while keeping the
   per-span bold/underline/reverse styling.
+- `answer_hint` on `begin_prompt()`/`PromptLine.start()`: replaces the default
+  trailing `[Press "y" or ESC]` text for the `Y`/`y` modes, with `{mode}`
+  substituted for the live mode letter.  The template is plain text (`.replace`,
+  not `.format`), so an application can bracket its own question, e.g.
+  `'["{mode}" or ESC] ⚠️'`, without escaping braces.
+- `add_prompt_header(align='center')`: pads the prompt row so it sits in the
+  middle of the pad width.  The offset is measured in display cells from the
+  composed line, so wide glyphs and emoji presentation selectors stay centred.
+- `ConsoleWindow.prompt_separator_attr`: an attribute applied to the separator
+  rule only while an in-place prompt is live (`None`, the default, keeps the
+  rule plain).  Lets the chrome recede behind the one line keys can reach.
 - `suspend_curses()`/`resume_curses()` on `ConsoleWindow`: leave curses mode
   with `endwin()` while keeping the window (pads, content model, pick state)
   alive, then reattach a screen and repaint.  This is the supported way for an
@@ -246,6 +262,14 @@ This project follows [Semantic Versioning](https://semver.org/).
   No in-repo code used it.
 
 ### Fixed
+- `textwidth` now counts an emoji presentation selector (`U+FE0F`) as a cell
+  when it follows a narrow, non-ASCII base, so `⚠️` measures two cells as
+  terminals draw it instead of one.  Every measurement that follows the glyph
+  (`string_width()`, `truncate()`, `ljust()`/`rjust()`, `cell_to_index()`) was
+  one cell short, which shifted following text left and padded rows short --
+  visible as a crammed space after the glyph.  A base that is already two cells
+  wide (`⌚`, `⌛`) and ASCII bases are left alone, and `char_width()` stays per
+  code point so the cursor can never land between a base and its selector.
 - `win._start_curses()` once again *reattaches* the window.  The 1.4.x
   compatibility hook is still called in the wild (psistat's "dump event log"
   path uses `self.window._start_curses()` to return from shell mode), but the

console_window-2.1.2/tests/test_demo_mode.py

@@ -0,0 +1,97 @@
+import curses
+
+import pytest
+
+from console_window.opts import ConsoleWindowOpts
+from console_window.window import ConsoleWindow
+
+
+def make_window(demo_mode=False, last_demo_key=''):
+    win = object.__new__(ConsoleWindow)
+    win.opts = ConsoleWindowOpts(demo_mode=demo_mode)
+    win.last_demo_key = last_demo_key
+    return win
+
+
+def test_toggle_on_preserves_last_demo_key():
+    # The audit bug: ``enabled is None`` must not be treated as "disable".
+    win = make_window(demo_mode=False, last_demo_key='k')
+    assert win.set_demo_mode(None) is True
+    assert win.opts.demo_mode is True
+    assert win.last_demo_key == 'k'
+
+
+def test_toggle_off_clears_last_demo_key():
+    win = make_window(demo_mode=True, last_demo_key='k')
+    assert win.set_demo_mode(None) is False
+    assert win.opts.demo_mode is False
+    assert win.last_demo_key == ''
+
+
+def test_explicit_enable_preserves_last_demo_key():
+    win = make_window(demo_mode=False, last_demo_key='k')
+    assert win.set_demo_mode(True) is True
+    assert win.opts.demo_mode is True
+    assert win.last_demo_key == 'k'
+
+
+def test_explicit_disable_clears_last_demo_key():
+    win = make_window(demo_mode=True, last_demo_key='k')
+    assert win.set_demo_mode(False) is False
+    assert win.opts.demo_mode is False
+    assert win.last_demo_key == ''
+
+
+def test_return_value_tracks_new_state():
+    win = make_window(demo_mode=False)
+    assert win.set_demo_mode(True) is True
+    assert win.set_demo_mode(True) is True
+    assert win.set_demo_mode(False) is False
+    assert win.set_demo_mode(None) is True  # toggles back on
+
+
+@pytest.mark.parametrize(('key', 'label'), [
+    (curses.KEY_LEFT, 'LEFT'),
+    (curses.KEY_RIGHT, 'RIGHT'),
+    (curses.KEY_UP, 'UP'),
+    (curses.KEY_DOWN, 'DOWN'),
+    (curses.KEY_HOME, 'HOME'),
+    (curses.KEY_END, 'END'),
+    (curses.KEY_PPAGE, 'PPAGE'),
+    (curses.KEY_NPAGE, 'NPAGE'),
+    (curses.KEY_F5, 'F5'),
+    (curses.KEY_BTAB, 'BTAB'),
+    (curses.KEY_RESIZE, 'RESIZE'),
+])
+def test_curses_keys_get_readable_demo_labels(key, label):
+    # A taken LEFT/RIGHT reaches demo mode as an application key; the header
+    # must name it instead of showing the old '???' fallback.
+    assert make_window()._format_key_for_demo(key) == label  # pylint: disable=protected-access
+
+
+@pytest.mark.parametrize(('key', 'label'), [
+    (ord('p'), ' p '),
+    (27, 'ESC'),
+    (ord('\t'), 'TAB'),
+    (10, 'ENT'),
+    (13, 'ENT'),
+    (curses.KEY_ENTER, 'ENT'),
+    (ord(' '), 'SPC'),
+    (8, 'BSP'),
+    (127, 'BSP'),
+    (curses.KEY_BACKSPACE, 'BSP'),
+    (curses.KEY_DC, 'DEL'),
+    (ord('\x15'), '^U'),
+    (0, '^@'),
+    (31, '^_'),
+])
+def test_known_keys_keep_their_compact_demo_labels(key, label):
+    assert make_window()._format_key_for_demo(key) == label  # pylint: disable=protected-access
+
+
+def test_unknown_keys_show_their_code_instead_of_question_marks():
+    win = make_window()
+    assert win._format_key_for_demo(999) == '<999>'  # pylint: disable=protected-access
+    # Regression: no key code may fall back to the old '???' placeholder.
+    for key in [*range(0, 300), 999, 1000]:
+        assert win._format_key_for_demo(key) != '???'  # pylint: disable=protected-access

{console_window-2.1.1 → console_window-2.1.2}/tests/test_interactive.py

@@ -95,6 +95,17 @@ def test_prompt_passthrough_records_demo_indicator(make):
     assert win.last_demo_key == ' p '
 
 
+def test_taken_arrow_key_is_named_in_demo_indicator(make):
+    # grub-wiz takes LEFT/RIGHT for itself; the demo header must name the key
+    # it recorded instead of showing the old '???' placeholder.
+    win, backend = make(demo_mode=True,
+                        taken_nav_keys={curses.KEY_LEFT: 'prev',
+                                        curses.KEY_RIGHT: 'next'})
+    backend.queue_keys(curses.KEY_LEFT)
+    assert win.prompt(seconds=0.5) == curses.KEY_LEFT
+    assert win.last_demo_key == 'LEFT'
+
+
 def test_prompt_passthrough_forwards_escape_without_handled_keys(make):
     # The gap that forced every InlineConfirmation caller to discover
     # handled_keys: ESC must reach a passthrough editor as a normal key.

console_window-2.1.2/tests/test_prompt_window.py

@@ -0,0 +1,288 @@
+"""ConsoleWindow's in-place prompt lifecycle and drawing helpers."""
+
+import curses
+
+import console_window.window as window_mod
+from console_window import textwidth
+from console_window.backend import HeadlessBackend
+from console_window.opts import ConsoleWindowOpts
+from console_window.window import ConsoleWindow
+
+
+def _window(rows=10, cols=40, **opts):
+    return ConsoleWindow(opts=ConsoleWindowOpts(**opts),
+                         backend=HeadlessBackend(rows=rows, cols=cols),
+                         singleton=False)
+
+
+def test_begin_prompt_enables_passthrough_and_end_restores_it():
+    win = _window()
+    try:
+        assert win.passthrough_mode is False
+        assert win.begin_prompt('Proceed?') is True
+        assert win.prompt_active is True
+        assert win.passthrough_mode is True
+
+        win.end_prompt()
+
+        assert win.prompt_active is False
+        assert win.passthrough_mode is False
+    finally:
+        win.stop_curses()
+
+
+def test_begin_prompt_preserves_an_already_enabled_passthrough():
+    win = _window()
+    try:
+        win.passthrough_mode = True
+        win.begin_prompt('Proceed?')
+
+        win.end_prompt()
+
+        assert win.passthrough_mode is True
+    finally:
+        win.stop_curses()
+
+
+def test_callback_runs_after_passthrough_is_restored():
+    win = _window()
+    try:
+        seen = []
+
+        def on_confirm(answer):
+            seen.append((answer, win.passthrough_mode, win.prompt_active))
+
+        win.begin_prompt('Proceed?', mode='y', on_confirm=on_confirm)
+        assert win.handle_prompt_key(ord('y')) == 'confirmed'
+
+        assert seen == [('y', False, False)]
+    finally:
+        win.stop_curses()
+
+
+def test_callback_may_begin_the_next_prompt():
+    win = _window()
+    try:
+        def ask_again(_answer):
+            assert win.passthrough_mode is False
+            win.begin_prompt('Again?', mode='y')
+
+        win.begin_prompt('First?', mode='y', on_confirm=ask_again)
+        win.handle_prompt_key(ord('y'))
+
+        assert win.prompt_active is True
+        assert win.prompt_line.prompt == 'Again?'
+        assert win.passthrough_mode is True
+
+        assert win.handle_prompt_key(ord('y')) == 'confirmed'
+        assert win.prompt_active is False
+        assert win.passthrough_mode is False
+    finally:
+        win.stop_curses()
+
+
+def test_handle_prompt_key_is_continue_when_inactive():
+    win = _window()
+    try:
+        assert win.handle_prompt_key(ord('y')) == 'continue'
+    finally:
+        win.stop_curses()
+
+
+def test_add_prompt_header_is_a_noop_when_inactive():
+    win = _window()
+    try:
+        before = win.head.row_cnt
+        assert win.add_prompt_header() is False
+        assert win.head.row_cnt == before
+    finally:
+        win.stop_curses()
+
+
+def test_add_prompt_lines_draws_prompt_then_dim_hint():
+    win = _window()
+    try:
+        win.begin_prompt('Confirm?', hint='Press Y', mode='text', seed='5')
+
+        assert win.add_prompt_lines() is True
+
+        assert win.body.texts == ['Confirm?: 5│', 'Press Y']
+        assert win.body.text_attrs[0] == [(curses.A_BOLD, len('Confirm?: 5│'))]
+        assert win.body.text_attrs[1] == [(curses.A_DIM, len('Press Y'))]
+        for context in win.body.contexts:
+            assert context.genre == 'TRANSIENT'
+            assert context.pickable is False
+    finally:
+        win.stop_curses()
+
+
+def test_add_prompt_header_draws_the_prompt_as_a_bold_header():
+    win = _window()
+    try:
+        win.begin_prompt('Proceed?', mode='y')
+
+        assert win.add_prompt_header() is True
+        assert win.head.texts == ['Proceed?  [Press "y" or ESC]']
+        assert win.head.text_attrs[0] == [
+            (curses.A_BOLD, len('Proceed?  [Press "y" or ESC]'))]
+    finally:
+        win.stop_curses()
+
+
+def test_add_prompt_lines_truncates_the_hint():
+    win = _window(rows=10, cols=12)
+    try:
+        win.begin_prompt('X', hint='h' * 100, mode='text')
+
+        win.add_prompt_lines()
+
+        hint_text = win.body.texts[1]
+        assert len(hint_text) == max(10, win.cols - 2)
+    finally:
+        win.stop_curses()
+
+
+def test_every_key_is_consumable_while_active():
+    win = _window()
+    try:
+        win.begin_prompt('Value', mode='text')
+
+        for key in (ord('j'), curses.KEY_DOWN, ord('q')):
+            assert win.handle_prompt_key(key) == 'continue'
+            assert win.prompt_active is True
+    finally:
+        win.stop_curses()
+
+
+# --- answer hint ------------------------------------------------------------
+
+def test_answer_hint_replaces_the_default_suffix():
+    win = _window()
+    try:
+        win.begin_prompt('Proceed?', mode='y',
+                         answer_hint='["{mode}" or ESC] ⚠️')
+
+        assert win.prompt_line.get_display_string() == 'Proceed?  ["y" or ESC] ⚠️'
+    finally:
+        win.stop_curses()
+
+
+def test_answer_hint_substitutes_the_live_mode_letter():
+    win = _window()
+    try:
+        win.begin_prompt('Proceed?', mode='Y',
+                         answer_hint='["{mode}" or ESC]')
+
+        assert win.prompt_line.get_display_string() == 'Proceed?  ["Y" or ESC]'
+    finally:
+        win.stop_curses()
+
+
+def test_answer_hint_is_plain_text_not_a_format_string():
+    # Braces are caller text; a stray '{' must not raise at paint time.
+    win = _window()
+    try:
+        win.begin_prompt('Proceed?', mode='y',
+                         answer_hint='["{mode}" or ESC] {⚠️}')
+
+        assert win.prompt_line.get_display_string() == 'Proceed?  ["y" or ESC] {⚠️}'
+    finally:
+        win.stop_curses()
+
+
+def test_answer_hint_is_cleared_with_the_prompt():
+    win = _window()
+    try:
+        win.begin_prompt('Proceed?', mode='y', answer_hint='["{mode}" or ESC]')
+        win.end_prompt()
+
+        assert win.prompt_line.answer_hint == ''
+    finally:
+        win.stop_curses()
+
+
+# --- centered prompt header -------------------------------------------------
+
+def test_add_prompt_header_centers_within_the_pad_width():
+    win = _window(rows=10, cols=40)
+    try:
+        win.begin_prompt('Proceed?', mode='y')
+
+        assert win.add_prompt_header(align='center') is True
+
+        display = 'Proceed?  [Press "y" or ESC]'
+        lead = (win.get_pad_width() - textwidth.string_width(display)) // 2
+        assert win.head.texts == [' ' * lead + display]
+    finally:
+        win.stop_curses()
+
+
+def test_centering_measures_emoji_presentation_width():
+    # Each ⚠️ is two cells but two code points (base + VS16), so a correct
+    # measurement equals the code-point count.  Counting only the base (the
+    # pre-VS16 behaviour) came out two cells short and pushed the line right,
+    # which is what made the space after the glyph look cramped.
+    win = _window(rows=10, cols=40)
+    try:
+        win.begin_prompt('⚠️ Go?', mode='y', answer_hint='["{mode}" or ESC] ⚠️')
+
+        display = win.prompt_line.get_display_string()
+        assert textwidth.string_width(display) == len(display)
+
+        win.add_prompt_header(align='center')
+
+        lead = (win.get_pad_width() - textwidth.string_width(display)) // 2
+        assert win.head.texts == [' ' * lead + display]
+    finally:
+        win.stop_curses()
+
+
+def test_add_prompt_header_align_never_adds_padding_when_too_wide():
+    # Pad width is cols-1, so a 7-column window cannot hold the prompt plus a
+    # pad: centering must degrade to plain (left-aligned, truncated) drawing.
+    win = _window(rows=10, cols=8)
+    try:
+        win.begin_prompt('Proceed?', mode='y')
+
+        win.add_prompt_header(align='center')
+
+        assert win.head.texts[0] == 'Proceed'
+    finally:
+        win.stop_curses()
+
+
+# --- separator dimming ------------------------------------------------------
+
+def _hline_attrs(win):
+    return [args[4] for _name, args, _kwargs in win._backend.screen.calls_named('hline')]
+
+
+def test_separator_dims_only_while_a_prompt_is_live(monkeypatch):
+    if not hasattr(window_mod.curses, 'ACS_HLINE'):
+        monkeypatch.setattr(window_mod.curses, 'ACS_HLINE', '-', raising=False)
+    win = _window(rows=10, cols=40)
+    try:
+        win.prompt_separator_attr = curses.A_DIM
+
+        win._draw_separator_and_indicator()
+        assert _hline_attrs(win)[-1] == curses.A_NORMAL
+
+        win.begin_prompt('Proceed?', mode='y')
+        win._draw_separator_and_indicator()
+        assert _hline_attrs(win)[-1] == curses.A_DIM
+    finally:
+        win.stop_curses()
+
+
+def test_separator_stays_plain_when_no_attr_is_configured(monkeypatch):
+    if not hasattr(window_mod.curses, 'ACS_HLINE'):
+        monkeypatch.setattr(window_mod.curses, 'ACS_HLINE', '-', raising=False)
+    win = _window(rows=10, cols=40)
+    try:
+        win.begin_prompt('Proceed?', mode='y')
+
+        win._draw_separator_and_indicator()
+
+        assert _hline_attrs(win)[-1] == curses.A_NORMAL
+    finally:
+        win.stop_curses()

{console_window-2.1.1 → console_window-2.1.2}/tests/test_textwidth.py

@@ -3,6 +3,8 @@ from console_window import textwidth as tw
 CJK = '世'          # U+4E16, East-Asian Wide -> 2 cells
 COMBINING = '\u0301'  # combining acute accent -> 0 cells
 ZWJ = '\u200d'     # zero-width joiner (Cf) -> 0 cells
+VS16 = '\ufe0f'    # emoji presentation selector
+WARN = f'\u26a0{VS16}'  # ⚠️: ambiguous base + VS16, drawn 2 cells by terminals
 
 # --- char_width / string_width ----------------------------------------------
 
@@ -33,6 +35,38 @@ def test_string_width_ignores_combining_and_zwj():
     assert tw.string_width(f'e{COMBINING}') == 1  # é as e + combining accent
     assert tw.string_width(f'{CJK}{ZWJ}{CJK}') == 4
 
+
+def test_string_width_counts_emoji_presentation_as_two_cells():
+    # ⚠️ is U+26A0 (East-Asian Ambiguous) + VS16.  Terminals honour VS16 and
+    # draw it two cells wide, so a one-cell measurement shifts every following
+    # character by a column and crams the space after the glyph.
+    assert tw.char_width('\u26a0') == 1        # per code point: unchanged
+    assert tw.string_width(WARN) == 2
+    assert tw.string_width(f'{WARN} x') == 4
+
+
+def test_string_width_does_not_widen_wide_or_ascii_bases_again():
+    assert tw.string_width(f'\u231a{VS16}') == 2   # ⌚ already wide
+    assert tw.string_width(f'a{VS16}') == 1        # terminals keep ASCII narrow
+    assert tw.string_width(VS16) == 0              # selector with no base
+
+
+def test_ljust_pads_emoji_presentation_rows_to_the_requested_cells():
+    padded = tw.ljust(f'{WARN} x', 6)
+    assert padded == f'{WARN} x  '
+    assert tw.string_width(padded) == 6
+
+
+def test_truncate_keeps_the_presentation_selector_with_its_base():
+    assert tw.truncate(f'{WARN} commit', 2) == WARN
+    assert tw.truncate(f'{WARN} commit', 1) == '\u26a0'
+
+
+def test_cell_to_index_agrees_with_string_width_for_emoji():
+    text = f'{WARN} x'
+    assert tw.cell_to_index(text, 2) == len(WARN)
+    assert tw.cell_to_index(text, tw.string_width(text)) == len(text)
+
 # --- truncate / ljust / rjust -----------------------------------------------
 
 def test_truncate_narrow():

console_window-2.1.1/tests/test_demo_mode.py

@@ -1,46 +0,0 @@
-from console_window.opts import ConsoleWindowOpts
-from console_window.window import ConsoleWindow
-
-
-def make_window(demo_mode=False, last_demo_key=''):
-    win = object.__new__(ConsoleWindow)
-    win.opts = ConsoleWindowOpts(demo_mode=demo_mode)
-    win.last_demo_key = last_demo_key
-    return win
-
-
-def test_toggle_on_preserves_last_demo_key():
-    # The audit bug: ``enabled is None`` must not be treated as "disable".
-    win = make_window(demo_mode=False, last_demo_key='k')
-    assert win.set_demo_mode(None) is True
-    assert win.opts.demo_mode is True
-    assert win.last_demo_key == 'k'
-
-
-def test_toggle_off_clears_last_demo_key():
-    win = make_window(demo_mode=True, last_demo_key='k')
-    assert win.set_demo_mode(None) is False
-    assert win.opts.demo_mode is False
-    assert win.last_demo_key == ''
-
-
-def test_explicit_enable_preserves_last_demo_key():
-    win = make_window(demo_mode=False, last_demo_key='k')
-    assert win.set_demo_mode(True) is True
-    assert win.opts.demo_mode is True
-    assert win.last_demo_key == 'k'
-
-
-def test_explicit_disable_clears_last_demo_key():
-    win = make_window(demo_mode=True, last_demo_key='k')
-    assert win.set_demo_mode(False) is False
-    assert win.opts.demo_mode is False
-    assert win.last_demo_key == ''
-
-
-def test_return_value_tracks_new_state():
-    win = make_window(demo_mode=False)
-    assert win.set_demo_mode(True) is True
-    assert win.set_demo_mode(True) is True
-    assert win.set_demo_mode(False) is False
-    assert win.set_demo_mode(None) is True  # toggles back on

console_window-2.1.1/tests/test_prompt_window.py

@@ -1,152 +0,0 @@
-"""ConsoleWindow's in-place prompt lifecycle and drawing helpers."""
-
-import curses
-
-from console_window.backend import HeadlessBackend
-from console_window.opts import ConsoleWindowOpts
-from console_window.window import ConsoleWindow
-
-
-def _window(rows=10, cols=40, **opts):
-    return ConsoleWindow(opts=ConsoleWindowOpts(**opts),
-                         backend=HeadlessBackend(rows=rows, cols=cols),
-                         singleton=False)
-
-
-def test_begin_prompt_enables_passthrough_and_end_restores_it():
-    win = _window()
-    try:
-        assert win.passthrough_mode is False
-        assert win.begin_prompt('Proceed?') is True
-        assert win.prompt_active is True
-        assert win.passthrough_mode is True
-
-        win.end_prompt()
-
-        assert win.prompt_active is False
-        assert win.passthrough_mode is False
-    finally:
-        win.stop_curses()
-
-
-def test_begin_prompt_preserves_an_already_enabled_passthrough():
-    win = _window()
-    try:
-        win.passthrough_mode = True
-        win.begin_prompt('Proceed?')
-
-        win.end_prompt()
-
-        assert win.passthrough_mode is True
-    finally:
-        win.stop_curses()
-
-
-def test_callback_runs_after_passthrough_is_restored():
-    win = _window()
-    try:
-        seen = []
-
-        def on_confirm(answer):
-            seen.append((answer, win.passthrough_mode, win.prompt_active))
-
-        win.begin_prompt('Proceed?', mode='y', on_confirm=on_confirm)
-        assert win.handle_prompt_key(ord('y')) == 'confirmed'
-
-        assert seen == [('y', False, False)]
-    finally:
-        win.stop_curses()
-
-
-def test_callback_may_begin_the_next_prompt():
-    win = _window()
-    try:
-        def ask_again(_answer):
-            assert win.passthrough_mode is False
-            win.begin_prompt('Again?', mode='y')
-
-        win.begin_prompt('First?', mode='y', on_confirm=ask_again)
-        win.handle_prompt_key(ord('y'))
-
-        assert win.prompt_active is True
-        assert win.prompt_line.prompt == 'Again?'
-        assert win.passthrough_mode is True
-
-        assert win.handle_prompt_key(ord('y')) == 'confirmed'
-        assert win.prompt_active is False
-        assert win.passthrough_mode is False
-    finally:
-        win.stop_curses()
-
-
-def test_handle_prompt_key_is_continue_when_inactive():
-    win = _window()
-    try:
-        assert win.handle_prompt_key(ord('y')) == 'continue'
-    finally:
-        win.stop_curses()
-
-
-def test_add_prompt_header_is_a_noop_when_inactive():
-    win = _window()
-    try:
-        before = win.head.row_cnt
-        assert win.add_prompt_header() is False
-        assert win.head.row_cnt == before
-    finally:
-        win.stop_curses()
-
-
-def test_add_prompt_lines_draws_prompt_then_dim_hint():
-    win = _window()
-    try:
-        win.begin_prompt('Confirm?', hint='Press Y', mode='text', seed='5')
-
-        assert win.add_prompt_lines() is True
-
-        assert win.body.texts == ['Confirm?: 5│', 'Press Y']
-        assert win.body.text_attrs[0] == [(curses.A_BOLD, len('Confirm?: 5│'))]
-        assert win.body.text_attrs[1] == [(curses.A_DIM, len('Press Y'))]
-        for context in win.body.contexts:
-            assert context.genre == 'TRANSIENT'
-            assert context.pickable is False
-    finally:
-        win.stop_curses()
-
-
-def test_add_prompt_header_draws_the_prompt_as_a_bold_header():
-    win = _window()
-    try:
-        win.begin_prompt('Proceed?', mode='y')
-
-        assert win.add_prompt_header() is True
-        assert win.head.texts == ['Proceed?  [Press "y" or ESC]']
-        assert win.head.text_attrs[0] == [
-            (curses.A_BOLD, len('Proceed?  [Press "y" or ESC]'))]
-    finally:
-        win.stop_curses()
-
-
-def test_add_prompt_lines_truncates_the_hint():
-    win = _window(rows=10, cols=12)
-    try:
-        win.begin_prompt('X', hint='h' * 100, mode='text')
-
-        win.add_prompt_lines()
-
-        hint_text = win.body.texts[1]
-        assert len(hint_text) == max(10, win.cols - 2)
-    finally:
-        win.stop_curses()
-
-
-def test_every_key_is_consumable_while_active():
-    win = _window()
-    try:
-        win.begin_prompt('Value', mode='text')
-
-        for key in (ord('j'), curses.KEY_DOWN, ord('q')):
-            assert win.handle_prompt_key(key) == 'continue'
-            assert win.prompt_active is True
-    finally:
-        win.stop_curses()