backpack-backbone 0.3.2__tar.gz → 0.4.0__tar.gz

{backpack_backbone-0.3.2/backpack_backbone.egg-info → backpack_backbone-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backpack-backbone
-Version: 0.3.2
+Version: 0.4.0
 Summary: Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once.
 License: MIT
 Project-URL: Homepage, https://github.com/RedEraRrow/backbone
@@ -50,9 +50,9 @@ how to install anything it can't run without.
 ## What's in it
 
 **`ui`** - the visual layer. `Colors` (honours `NO_COLOR=1`), the global
-`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, `wrap_margins`,
-`rule`, `bar`, `header_box`, `sparkline`, `spinner`, `rate_of_change`, and
-the `SPIN` / `PARTS` / `SPARK` glyph sets. Also the ANSI-aware text
+`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, the progress
+bar (`progress_cells`, `get_progress_bar`), `sparkline`, `spinner`,
+`rate_of_change`, and the `SPIN` / `SPARK` glyph sets. Also the ANSI-aware text
 measuring (`visual_len`, `truncate_text`, `clip_ansi`, `strip_ansi`) that
 makes any of that survive colour codes and wide characters, and small
 formatters: `plural`, `human_gb`, `dir_size_kb`. The accent colour is chosen
@@ -60,16 +60,9 @@ with `set_accent` (an `ACCENT_PRESETS` key or `#RRGGBB`); a tool calls it once
 at startup from its own settings, and `accent_code` / `accent_label` let a
 settings screen check and name a value.
 
-**`prompt.settings`** - what a Settings screen is built from, so every
-tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
-`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
-`index_of` (the cursor back on the row just changed), `pick_option` (one of
-a fixed set of values) and `pick_accent` (the accent colour picker, each
-colour shown in itself).
-
 `from backbone import ...` exposes only a subset of `ui` (`Colors`, the
-margins and glyph sets, `spinner`, `content_width`, `rule`, `bar`,
-`header_box`, `wrap_margins`); import anything else from its module, e.g.
+margins and glyph sets, `spinner`, `content_width`); import anything else
+from its module, e.g.
 `from backbone.ui import human_gb`.
 
 **`prompt`** - the widgets. `select` (single or multi), `confirm`, `text`,
@@ -79,6 +72,13 @@ values: `calendar_select`, `datetime_edit`, `time_edit`,
 `system_editor_edit`. All resize-aware, all mouse-aware, all rendered through
 the same painter.
 
+**`prompt.settings`** - what a Settings screen is built from, so every
+tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
+`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
+`index_of` (the cursor back on the row just changed), `pick_option` (one of
+a fixed set of values) and `pick_accent` (the accent colour picker, each
+colour shown in itself).
+
 **`prompt.core`** - the primitives underneath: the screen-diff painter, key
 reading, the `Choice` and `Column` types, the footer hint bar (`hint`) and its
 click mapping, and `run_dashboard`.

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/README.md

@@ -32,9 +32,9 @@ how to install anything it can't run without.
 ## What's in it
 
 **`ui`** - the visual layer. `Colors` (honours `NO_COLOR=1`), the global
-`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, `wrap_margins`,
-`rule`, `bar`, `header_box`, `sparkline`, `spinner`, `rate_of_change`, and
-the `SPIN` / `PARTS` / `SPARK` glyph sets. Also the ANSI-aware text
+`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, the progress
+bar (`progress_cells`, `get_progress_bar`), `sparkline`, `spinner`,
+`rate_of_change`, and the `SPIN` / `SPARK` glyph sets. Also the ANSI-aware text
 measuring (`visual_len`, `truncate_text`, `clip_ansi`, `strip_ansi`) that
 makes any of that survive colour codes and wide characters, and small
 formatters: `plural`, `human_gb`, `dir_size_kb`. The accent colour is chosen
@@ -42,16 +42,9 @@ with `set_accent` (an `ACCENT_PRESETS` key or `#RRGGBB`); a tool calls it once
 at startup from its own settings, and `accent_code` / `accent_label` let a
 settings screen check and name a value.
 
-**`prompt.settings`** - what a Settings screen is built from, so every
-tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
-`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
-`index_of` (the cursor back on the row just changed), `pick_option` (one of
-a fixed set of values) and `pick_accent` (the accent colour picker, each
-colour shown in itself).
-
 `from backbone import ...` exposes only a subset of `ui` (`Colors`, the
-margins and glyph sets, `spinner`, `content_width`, `rule`, `bar`,
-`header_box`, `wrap_margins`); import anything else from its module, e.g.
+margins and glyph sets, `spinner`, `content_width`); import anything else
+from its module, e.g.
 `from backbone.ui import human_gb`.
 
 **`prompt`** - the widgets. `select` (single or multi), `confirm`, `text`,
@@ -61,6 +54,13 @@ values: `calendar_select`, `datetime_edit`, `time_edit`,
 `system_editor_edit`. All resize-aware, all mouse-aware, all rendered through
 the same painter.
 
+**`prompt.settings`** - what a Settings screen is built from, so every
+tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
+`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
+`index_of` (the cursor back on the row just changed), `pick_option` (one of
+a fixed set of values) and `pick_accent` (the accent colour picker, each
+colour shown in itself).
+
 **`prompt.core`** - the primitives underneath: the screen-diff painter, key
 reading, the `Choice` and `Column` types, the footer hint bar (`hint`) and its
 click mapping, and `run_dashboard`.

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/backbone/__init__.py

@@ -4,14 +4,9 @@ from .ui import (
     MARGIN_H,
     MARGIN_V,
     SPIN,
-    PARTS,
     SPARK,
     spinner,
     content_width,
-    rule,
-    bar,
-    header_box,
-    wrap_margins,
 )
 
 __all__ = [
@@ -19,12 +14,7 @@ __all__ = [
     "MARGIN_H",
     "MARGIN_V",
     "SPIN",
-    "PARTS",
     "SPARK",
     "spinner",
     "content_width",
-    "rule",
-    "bar",
-    "header_box",
-    "wrap_margins",
 ]

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/backbone/prompt/chrome.py

@@ -115,20 +115,30 @@ CHROME_HANDLED = object()      # the key was consumed; carry on with the loop
 CHROME_REDRAW = object()       # consumed, and the caller should repaint fully
 
 
+def has_owner(action_id: str) -> bool:
+    """Whether an action does anything in this app: the transport and volume
+    keys need a transport handler installed, ^O a player to reopen. Every
+    other action belongs to a screen, so it does."""
+    if action_id in ("global.playpause", "global.next", "global.prev") or action_id.startswith("volume."):
+        return _transport_handler is not None
+    if action_id == "global.player":
+        return _player_opener is not None
+    return True
+
+
 def chrome_hint_pairs(pairs) -> list:
     """A widget's hint pairs plus the transport keys, while audio is playing.
 
-    Only keys that will actually do something are advertised: the transport trio
-    needs a handler installed and ^O needs a player to reopen. `unboxed` covers
+    Only keys that will actually do something are advertised (has_owner). `unboxed` covers
     a terminal too narrow to draw the now-playing box: the keys are still live,
     so they are still listed.
     """
     items = list(pairs.items()) if isinstance(pairs, dict) else [tuple(p) for p in pairs]
     if ui.footer_active() or ui.footer_unboxed():
-        if _transport_handler is not None:
+        if has_owner("global.playpause"):
             items += [(keys.label("global.playpause"), "play/pause"),
                       (keys.label("global.next", "global.prev"), "next/prev")]
-        if _player_opener is not None:
+        if has_owner("global.player"):
             items += [(keys.label("global.player"), "player")]
     return items
 

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/backbone/prompt/core.py

@@ -2499,7 +2499,7 @@ def run_dashboard(render, interval: float = 1.0, quit_action: str = "list.quit",
     `quit_action` binding (see backbone.keys) is pressed.
 
     `render()` takes no arguments and returns the whole frame as a list of
-    lines, each carrying its own left-margin indent (see header_box()). It
+    lines, each carrying its own left-margin indent (box_lines() adds it). It
     runs once every `interval` seconds; keypresses and resizes are checked
     every `poll` seconds regardless, and a resize renders at once.
 

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/backbone/prompt/keymap.py

@@ -30,13 +30,17 @@ def _row(a: keys.Action) -> Choice:
                          "changed" if changed else ""])
 
 
-def _choices() -> list:
+def _choices(scopes) -> list:
+    """Every action this app has a use for, by its screen: only `scopes`
+    (all, when None), and no transport or volume keys without a player."""
+    from backbone.prompt.chrome import has_owner
     out: list = []
     for scope, title in keys.scopes():
-        if scope == "keys_editor":
-            continue                                 # listed last, below
-        out.append(separator(title))
-        out += [_row(a) for a in keys.actions(scope)]
+        if scope == "keys_editor" or (scopes is not None and scope not in scopes):
+            continue                                 # this page's own are listed last, below
+        rows = [_row(a) for a in keys.actions(scope) if has_owner(a.id)]
+        if rows:
+            out += [separator(title), *rows]
     out.append(separator("This page"))
     out += [_row(a) for a in keys.actions("keys_editor")]
     return out
@@ -102,8 +106,9 @@ def _remove_key(aid: str) -> None:
     ui.show_status(f"{keys.glyph(key)} removed" + ("" if len(bound) > 1 else ": the action has no key now"))
 
 
-def keys_editor() -> None:
-    """The Key bindings page. Returns when backed out of."""
+def keys_editor(scopes: list | None = None) -> None:
+    """The Key bindings page, for the key groups (keys.define scopes) in
+    `scopes`, or every one defined. Returns when backed out of."""
     from backbone.prompt.lists import ListPlace, select
     place = ListPlace()
     while True:
@@ -124,7 +129,7 @@ def keys_editor() -> None:
             hints[keys.label(aid)] = {"remove": "remove a key", "reset": "reset",
                                       "reset_all": "reset all"}[name]
 
-        choice = select("", _choices(), columns=_COLUMNS, place=place,
+        choice = select("", _choices(scopes), columns=_COLUMNS, place=place,
                         header=lambda: rounded_header("Key bindings", "",
                                                       f"{changed} changed" if changed else "all default"),
                         extra_hints={"↵": "add a key"},

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/backbone/ui.py

@@ -103,8 +103,7 @@ MARGIN_V = 1   # rows reserved on each vertical side (top and bottom)
 FOOTER_GLYPH_COLS = ((0, 2), (4, 2))
 
 class Colors:
-    """The named palette every widget uses, plus semantic colours for a tool's
-    own views (FRAME, TEAL, AMBER, RED, TXT, MUTE) and the short aliases R and B.
+    """The named palette every widget uses, and RED for what failed.
     All empty when colour is off (NO_COLOR, or set_colour(False))."""
     PRIMARY = "\033[1;37m" # Bold white
     WHITE = "\033[37m" # Normal white
@@ -127,23 +126,14 @@ class Colors:
     BAR_DIM = "\033[48;5;235m"
     HIDE = "\033[?25l"
     SHOW = "\033[?25h"
-    # semantic colours for a tool's own views (backcrack's watch uses RED for failures)
-    FRAME = "\033[38;5;239m"
-    TEAL = "\033[38;5;43m"
-    AMBER = "\033[38;5;179m"
-    RED = "\033[38;5;167m"
-    TXT = "\033[38;5;252m"
-    MUTE = "\033[38;5;243m"
-    R = RESET            # short aliases
-    B = BOLD
+    RED = "\033[38;5;167m"   # a failure: a text field's problem, backcrack's FAIL lines
 
 
 # The styling half of Colors: everything that paints rather than moves the
 # cursor. Suppressing colour must not suppress HIDE/SHOW, which are cursor
 # control and still needed on a pipe.
 _STYLE_NAMES = ('PRIMARY', 'WHITE', 'ACCENT', 'ACCENT2', 'CYAN', 'YELLOW', 'MAGENTA', 'GREEN',
-                'DIM', 'BOLD', 'ITALIC', 'UNDERLINE', 'RESET', 'BACK', 'INVERT', 'BAR', 'BAR_DIM',
-                'FRAME', 'TEAL', 'AMBER', 'RED', 'TXT', 'MUTE', 'R', 'B')
+                'DIM', 'BOLD', 'ITALIC', 'UNDERLINE', 'RESET', 'BACK', 'INVERT', 'BAR', 'BAR_DIM', 'RED')
 _STYLE_CODES = {name: getattr(Colors, name) for name in _STYLE_NAMES}
 
 
@@ -1128,8 +1118,6 @@ C = Colors   # the short name every widget uses
 
 SPIN = list("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
 
-PARTS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"]   # eighth-block fill steps
-
 SPARK = "▁▂▃▄▅▆▇█"
 
 def content_width(min_width: int = 1) -> int:
@@ -1140,21 +1128,6 @@ def content_width(min_width: int = 1) -> int:
     """
     return max(min_width, get_terminal_width() - 2 * MARGIN_H)
 
-def rule(n: int) -> str:
-    return "─" * n
-
-def bar(pct: int, width: int, color: str = "") -> str:
-    color = color or Colors.TEAL
-    pct = max(0, min(100, pct))
-    eighths = pct * width * 8 // 100
-    full, rem = divmod(eighths, 8)
-    out = color + "█" * full
-    if rem and full < width:
-        out += PARTS[rem]
-        full += 1
-    out += Colors.MUTE + "─" * (width - full) + Colors.R
-    return out
-
 def rate_of_change(history: list, now: float, value: float, window: float = 20.0, max_len: int = 60):
     """Tracks `value` over time in `history` (a list of (ts, value) pairs,
     mutated in place and capped to `max_len` entries) and returns its rate
@@ -1189,68 +1162,6 @@ def sparkline(rate_history: list, rate: float, max_len: int = 14) -> str:
     mx = max(rate_history, default=1) or 1
     return "".join(SPARK[max(0, min(7, int(r / mx * 7.99)))] for r in rate_history)
 
-def header_box(left: str, right: str, cols: int, spin: str = "") -> list:
-    """The 3-line rounded header frame (top rule, title row, bottom rule)
-    for a live view - `cols` is total frame width, i.e. content_width()'s
-    return value. The title row's padding is computed from the *actual*
-    rendered pieces (left, right, spin), so the right border always lands
-    exactly under the corners no matter how any of the three are sized -
-    this single spot is the only place that math needs to be right.
-
-    Truncates `left` (then `right`, if even that isn't enough) so the row
-    never runs past `cols` regardless of terminal width - `right` (typically
-    a short, fixed-format clock) is kept whole for as long as it can be;
-    `left` (the variable, more compressible piece - a title/library name)
-    gives way first.
-
-    Bakes in its own MARGIN_H left indent (matching every hand-written
-    widget line in backbone/prompt/ - e.g. confirm()'s
-    f"  {message}") rather than relying on a wrapper to add it: a caller
-    driving its view through _Widget.render() (prompt/core.py) gets no
-    such wrapper, since _Widget only manages the vertical margin itself.
-    """
-    interior = cols - 2
-    # Reserve the spinner plus one pad column *before* sizing left/right, so
-    # truncating to fit `budget` always leaves room for pad >= 1 - flooring
-    # pad afterward instead (max(1, ...)) can push the row a column past the
-    # border once left+right already exactly fill the interior.
-    budget = max(0, interior - len(spin) - 1)
-    if visual_len(left) + visual_len(right) > budget:
-        right = truncate_text(right, min(visual_len(right), budget))
-        left = truncate_text(left, max(0, budget - visual_len(right)))
-    pad = max(0, interior - visual_len(left) - visual_len(right) - len(spin))
-    C = Colors
-    hpad = " " * MARGIN_H
-    return [
-        f"{hpad}{C.FRAME}╭{rule(interior)}╮{C.R}",
-        f"{hpad}{C.FRAME}│{C.B}{left}{C.R}{' ' * pad}{C.TXT}{right}{C.R}{spin}{C.FRAME}│{C.R}",
-        f"{hpad}{C.FRAME}╰{rule(interior)}╯{C.R}",
-    ]
-
-def wrap_margins(lines: list, width: int = None) -> str:
-    """Applies the global MARGIN_H/MARGIN_V inset plus per-line
-    clear-to-end-of-line, ready for one `sys.stdout.write` - the standard
-    back* frame render (pair with an `ESC[H` cursor-home beforehand).
-
-    Joins with \\r\\n, not \\n: raw terminal mode (tty.setraw, used by
-    backbone.prompt.core for key reading) clears OPOST, so the terminal
-    stops translating a bare \\n into a carriage return - every line after
-    the first would otherwise start wherever the previous one ended instead
-    of column 1.
-
-    `width` (typically content_width()'s return value), if given, clips
-    every line to it first - a safety net so one field a caller forgot to
-    size itself can't overflow the whole frame. Hand-tuned per-field
-    truncation still reads better (an ellipsis where it makes sense, not a
-    hard cut mid-word); this is the guarantee behind it, not a replacement.
-    """
-    if width is not None:
-        lines = [clip_ansi(line, width) for line in lines]
-    hpad = " " * MARGIN_H
-    vpad = ["\033[K"] * MARGIN_V
-    out = vpad + [hpad + line + "\033[K" for line in lines] + vpad
-    return "\r\n".join(out)
-
 def spinner(frame: int) -> str:
     return SPIN[frame % len(SPIN)]
 
@@ -1276,33 +1187,13 @@ _ANSI_DEMO = re.compile(r"\033\[[0-9;]*[a-zA-Z]")
 
 
 def _demo() -> None:
-    """Self-check for the pure logic here, header_box's alignment above all.
+    """Self-check for the pure logic here.
     Runs without a terminal: `python3 -m backbone.ui`.
     """
-    for cols in (70, 100, 137):
-        for left, right, spin in (("  SHORT", "12:00:00  ", "X"), ("", "", ""), ("a" * 20, "b", "Y")):
-            top, mid, bot = header_box(left, right, cols, spin)
-            widths = {len(strip_ansi(top)), len(strip_ansi(mid)), len(strip_ansi(bot))}
-            assert len(widths) == 1, (cols, left, right, spin, widths)
-    # A left piece far longer than the frame must truncate, not overflow -
-    # the border still lines up at a width too narrow for it whole.
-    for cols in (10, 20, 40):
-        top, mid, bot = header_box("a" * 200, "12:00:00  ", cols, "X")
-        widths = {len(strip_ansi(top)), len(strip_ansi(mid)), len(strip_ansi(bot))}
-        assert len(widths) == 1, (cols, widths)
-        assert len(strip_ansi(mid)) == cols + MARGIN_H, (cols, len(strip_ansi(mid)))
     assert visual_len("plain") == 5
     assert visual_len(f"{Colors.BOLD}x{Colors.RESET}") == 1
     assert truncate_text("abcdefgh", 4) == "abc…"
     assert plural(1, "disc") == "1 disc" and plural(2, "disc") == "2 discs"
-    # Regression guard: wrap_margins must join with \r\n, not \n - under raw
-    # terminal mode (OPOST cleared) a bare \n never returns to column 1, and
-    # every line after the first starts wherever the previous one ended.
-    assert "\r\n" in wrap_margins(["a", "b"])
-    # wrap_margins(width=...) must clip an oversized line rather than let it
-    # overflow - the safety net behind every tool's own per-field sizing.
-    clipped = wrap_margins(["a" * 200], width=10).split("\r\n")[1]
-    assert len(strip_ansi(clipped)) <= 10 + MARGIN_H, clipped
     assert human_gb(1048576) == "1.0"
     hist = []
     assert rate_of_change(hist, 0.0, 0) is None            # first sample - no window yet

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0/backpack_backbone.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backpack-backbone
-Version: 0.3.2
+Version: 0.4.0
 Summary: Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once.
 License: MIT
 Project-URL: Homepage, https://github.com/RedEraRrow/backbone
@@ -50,9 +50,9 @@ how to install anything it can't run without.
 ## What's in it
 
 **`ui`** - the visual layer. `Colors` (honours `NO_COLOR=1`), the global
-`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, `wrap_margins`,
-`rule`, `bar`, `header_box`, `sparkline`, `spinner`, `rate_of_change`, and
-the `SPIN` / `PARTS` / `SPARK` glyph sets. Also the ANSI-aware text
+`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, the progress
+bar (`progress_cells`, `get_progress_bar`), `sparkline`, `spinner`,
+`rate_of_change`, and the `SPIN` / `SPARK` glyph sets. Also the ANSI-aware text
 measuring (`visual_len`, `truncate_text`, `clip_ansi`, `strip_ansi`) that
 makes any of that survive colour codes and wide characters, and small
 formatters: `plural`, `human_gb`, `dir_size_kb`. The accent colour is chosen
@@ -60,16 +60,9 @@ with `set_accent` (an `ACCENT_PRESETS` key or `#RRGGBB`); a tool calls it once
 at startup from its own settings, and `accent_code` / `accent_label` let a
 settings screen check and name a value.
 
-**`prompt.settings`** - what a Settings screen is built from, so every
-tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
-`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
-`index_of` (the cursor back on the row just changed), `pick_option` (one of
-a fixed set of values) and `pick_accent` (the accent colour picker, each
-colour shown in itself).
-
 `from backbone import ...` exposes only a subset of `ui` (`Colors`, the
-margins and glyph sets, `spinner`, `content_width`, `rule`, `bar`,
-`header_box`, `wrap_margins`); import anything else from its module, e.g.
+margins and glyph sets, `spinner`, `content_width`); import anything else
+from its module, e.g.
 `from backbone.ui import human_gb`.
 
 **`prompt`** - the widgets. `select` (single or multi), `confirm`, `text`,
@@ -79,6 +72,13 @@ values: `calendar_select`, `datetime_edit`, `time_edit`,
 `system_editor_edit`. All resize-aware, all mouse-aware, all rendered through
 the same painter.
 
+**`prompt.settings`** - what a Settings screen is built from, so every
+tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
+`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
+`index_of` (the cursor back on the row just changed), `pick_option` (one of
+a fixed set of values) and `pick_accent` (the accent colour picker, each
+colour shown in itself).
+
 **`prompt.core`** - the primitives underneath: the screen-diff painter, key
 reading, the `Choice` and `Column` types, the footer hint bar (`hint`) and its
 click mapping, and `run_dashboard`.

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "backpack-backbone"
-version = "0.3.2"
+version = "0.4.0"
 description = "Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once."
 requires-python = ">=3.10"
 readme = "README.md"

{backpack_backbone-0.3.2 → backpack_backbone-0.4.0}/tests/test_keys.py

@@ -105,5 +105,34 @@ class VolumeKeysTest(unittest.TestCase):
         self.assertEqual(got, ["vol_up", "vol_down"])
 
 
+class KeyBindingsPageTest(unittest.TestCase):
+    """The Key bindings page lists what the app has a use for: the screens it
+    names, and the transport and volume keys only with a player."""
+
+    def rows(self, scopes=None, handler=None, opener=None):
+        from backbone.prompt import chrome, keymap
+        with patch.object(chrome, "_transport_handler", handler), patch.object(chrome, "_player_opener", opener):
+            return [c.value or c.title for c in keymap._choices(scopes)]
+
+    def test_no_player_no_transport_keys(self):
+        rows = self.rows()
+        self.assertNotIn("global.playpause", rows)
+        self.assertNotIn("global.player", rows)
+        self.assertNotIn("Volume", rows)                  # its group goes with its keys
+        self.assertIn("global.help", rows)
+
+    def test_with_a_player_they_are_there(self):
+        rows = self.rows(handler=print, opener=print)
+        self.assertIn("global.playpause", rows)
+        self.assertIn("global.player", rows)
+        self.assertIn("volume.up", rows)
+
+    def test_only_the_named_groups(self):
+        rows = self.rows(["list"])
+        self.assertIn("list.up", rows)
+        self.assertNotIn("confirm.yes", rows)
+        self.assertEqual(rows[-4:], ["This page", "keys_editor.remove", "keys_editor.reset", "keys_editor.reset_all"])
+
+
 if __name__ == "__main__":
     unittest.main()