riched 0.1.0__py3-none-any.whl

riched/keybindings.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from importlib import resources
+from dataclasses import dataclass
+from typing import Any
+
+from textual.binding import Binding
+import yaml
+
+
+@dataclass(frozen=True)
+class KeyBindingHelpGroup:
+    title: str
+    rows: tuple[tuple[str, str], ...]
+
+
+def load_binding_spec() -> dict[str, Any]:
+    text = resources.files("riched").joinpath("bindings.yaml").read_text()
+    data = yaml.safe_load(text)
+    if not isinstance(data, dict):
+        raise ValueError("bindings.yaml must contain a mapping")
+    return data
+
+
+BINDING_SPEC = load_binding_spec()
+APP_COMMANDS = BINDING_SPEC["app"]["commands"]
+COMMANDS: list[tuple[str, str, str]] = [
+    (item["name"], item["description"], item["key"]) for item in APP_COMMANDS
+]
+DEFAULT_BINDINGS: dict[str, str] = {name: key for name, _, key in COMMANDS}
+
+
+def build_bindings() -> list[Binding]:
+    # priority=True so configured shortcuts override TextArea built-ins.
+    return [
+        Binding(default, name, desc, priority=True)
+        for name, desc, default in COMMANDS
+    ]
+
+
+def build_static_bindings(section: str) -> list[Binding]:
+    items = BINDING_SPEC[section]
+    return [
+        Binding(
+            item["key"],
+            item["action"],
+            item.get("description", ""),
+            show=item.get("show", True),
+        )
+        for item in items
+    ]
+
+
+def build_screen_bindings(screen: str) -> list[Binding]:
+    items = BINDING_SPEC["screens"][screen]
+    return [
+        Binding(
+            item["key"],
+            item["action"],
+            item.get("description", ""),
+            show=item.get("show", True),
+        )
+        for item in items
+    ]
+
+
+def binding_help_groups() -> list[KeyBindingHelpGroup]:
+    groups: list[KeyBindingHelpGroup] = []
+
+    app_rows = tuple(
+        (_display_key(item["key"]), item.get("description") or item["name"])
+        for item in BINDING_SPEC["app"]["commands"]
+    )
+    groups.append(KeyBindingHelpGroup("App", app_rows))
+
+    editor_rows = tuple(
+        (_display_key(item["key"]), item.get("description") or item["action"])
+        for item in BINDING_SPEC["editor"]
+    )
+    groups.append(KeyBindingHelpGroup("Editor", editor_rows))
+
+    for screen, items in BINDING_SPEC["screens"].items():
+        rows = tuple(
+            (_display_key(item["key"]), item.get("description") or item["action"])
+            for item in items
+        )
+        groups.append(KeyBindingHelpGroup(f"Screens / {screen}", rows))
+
+    return groups
+
+
+def _display_key(key: str) -> str:
+    return display_key(key)
+
+
+def display_key(key: str) -> str:
+    keys = [part.strip() for part in key.split(",") if part.strip()]
+    if not keys:
+        return key
+
+    without_super = [candidate for candidate in keys if "super" not in candidate]
+    candidates = without_super or keys
+
+    def score(candidate: str) -> tuple[int, int, int]:
+        parts = candidate.split("+")
+        has_cmd = "cmd" in parts
+        preferred_cmd_order = not (
+            "cmd" in parts
+            and "shift" in parts
+            and parts.index("shift") < parts.index("cmd")
+        )
+        preferred_alt_order = not (
+            "alt" in parts
+            and "shift" in parts
+            and parts.index("shift") < parts.index("alt")
+        )
+        return (
+            0 if has_cmd else 1,
+            0 if preferred_cmd_order else 1,
+            0 if preferred_alt_order else 1,
+        )
+
+    return min(candidates, key=score)

riched/screens.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual import events
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, OptionList, Static
+from textual.widgets.option_list import Option
+
+from .keybindings import binding_help_groups, build_screen_bindings
+
+MAX_QUICK_OPEN_RESULTS = 100
+
+
+class UnsavedChangesScreen(ModalScreen[str]):
+    """Prompt asking whether to save, discard, or cancel."""
+
+    BINDINGS = build_screen_bindings("unsaved_changes")
+
+    CSS = """
+    UnsavedChangesScreen {
+        align: center middle;
+    }
+    UnsavedChangesScreen > #dialog {
+        width: 64;
+        height: auto;
+        padding: 1 2;
+        background: $panel;
+        border: tall $accent;
+    }
+    UnsavedChangesScreen Label {
+        width: 100%;
+        content-align: center middle;
+        padding-bottom: 1;
+    }
+    UnsavedChangesScreen #buttons {
+        height: auto;
+        align: center middle;
+    }
+    UnsavedChangesScreen Button {
+        margin: 0 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label("Unsaved changes.\nSave before continuing?")
+            with Horizontal(id="buttons"):
+                yield Button("Save", variant="primary", id="save")
+                yield Button("Discard", variant="error", id="discard")
+                yield Button("Cancel", id="cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id or "cancel")
+
+    def on_key(self, event: events.Key) -> None:
+        focused = self.focused
+        if event.key == "space" and isinstance(focused, Button):
+            event.stop()
+            event.prevent_default()
+            focused.action_press()
+
+    def action_cancel(self) -> None:
+        self.dismiss("cancel")
+
+
+class QuickOpenScreen(ModalScreen[Path | None]):
+    """Fuzzy file picker."""
+
+    BINDINGS = build_screen_bindings("quick_open")
+
+    CSS = """
+    QuickOpenScreen {
+        align: center top;
+    }
+    QuickOpenScreen > #dialog {
+        offset-y: 2;
+        width: 76;
+        height: auto;
+        max-height: 24;
+        padding: 1 2;
+        background: $panel;
+        border: tall $accent;
+    }
+    QuickOpenScreen #query {
+        margin-bottom: 1;
+    }
+    QuickOpenScreen #results {
+        height: auto;
+        max-height: 18;
+    }
+    """
+
+    def __init__(self, root: Path, files: list[Path]) -> None:
+        super().__init__()
+        self.root = root
+        self.files = files
+        self._relative_paths = {
+            path: path.relative_to(root).as_posix() for path in files
+        }
+        self._option_paths: dict[str, Path] = {}
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Input(placeholder="Quick open", id="query")
+            yield OptionList(id="results")
+
+    def on_mount(self) -> None:
+        self._refresh_results("")
+        self.query_one("#query", Input).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "query":
+            self._refresh_results(event.value)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "query":
+            self._open_highlighted()
+
+    def on_option_list_option_selected(
+        self, event: OptionList.OptionSelected
+    ) -> None:
+        path = self._option_paths.get(event.option.id or "")
+        if path is not None:
+            self.dismiss(path)
+
+    def on_key(self, event: events.Key) -> None:
+        results = self.query_one("#results", OptionList)
+        if event.key == "up":
+            event.stop()
+            event.prevent_default()
+            results.action_cursor_up()
+        elif event.key == "down":
+            event.stop()
+            event.prevent_default()
+            results.action_cursor_down()
+        elif event.key == "enter":
+            event.stop()
+            event.prevent_default()
+            self._open_highlighted()
+
+    def action_close(self) -> None:
+        self.dismiss(None)
+
+    def _refresh_results(self, query: str) -> None:
+        results = self.query_one("#results", OptionList)
+        results.clear_options()
+        self._option_paths.clear()
+
+        matches = self._ranked_matches(query)
+        if not matches:
+            results.add_option(Option("No matches", id="no-matches", disabled=True))
+            return
+
+        options: list[Option] = []
+        for index, path in enumerate(matches[:MAX_QUICK_OPEN_RESULTS]):
+            option_id = str(index)
+            self._option_paths[option_id] = path
+            options.append(Option(self._relative_paths[path], id=option_id))
+        results.add_options(options)
+        results.highlighted = 0
+
+    def _ranked_matches(self, query: str) -> list[Path]:
+        stripped_query = query.strip()
+        if not stripped_query:
+            return sorted(self.files, key=lambda path: self._relative_paths[path].lower())
+
+        scored: list[tuple[tuple[int, int, int, int, str], Path]] = []
+        for path in self.files:
+            relative_path = self._relative_paths[path]
+            score = _fuzzy_score(stripped_query, relative_path)
+            if score is not None:
+                scored.append((score, path))
+        scored.sort(key=lambda item: item[0])
+        return [path for _score, path in scored]
+
+    def _open_highlighted(self) -> None:
+        results = self.query_one("#results", OptionList)
+        highlighted = results.highlighted
+        if highlighted is None:
+            return
+        try:
+            option = results.get_option_at_index(highlighted)
+        except Exception:
+            return
+        path = self._option_paths.get(option.id or "")
+        if path is not None:
+            self.dismiss(path)
+
+
+class KeysHelpScreen(ModalScreen[None]):
+    """Popup key binding help."""
+
+    BINDINGS = build_screen_bindings("keys_help")
+
+    CSS = """
+    KeysHelpScreen {
+        align: center middle;
+    }
+    KeysHelpScreen > #dialog {
+        width: 80%;
+        height: 80%;
+        max-width: 96;
+        padding: 1 2;
+        background: $panel;
+        border: tall $accent;
+    }
+    KeysHelpScreen Label {
+        height: auto;
+        margin-bottom: 1;
+        text-style: bold;
+    }
+    KeysHelpScreen #bindings-list {
+        width: 1fr;
+        height: 1fr;
+        padding: 0;
+        overflow-y: auto;
+    }
+    KeysHelpScreen .binding-group {
+        height: auto;
+        margin-bottom: 1;
+    }
+    KeysHelpScreen .binding-title {
+        height: auto;
+        color: $text-primary;
+        text-style: underline bold;
+    }
+    KeysHelpScreen .binding-row {
+        height: auto;
+        layout: horizontal;
+    }
+    KeysHelpScreen .binding-key {
+        width: 38;
+        height: auto;
+        color: $text-accent;
+        text-style: bold;
+        padding-right: 1;
+    }
+    KeysHelpScreen .binding-description {
+        width: 1fr;
+        height: auto;
+        color: $foreground;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label("Key Bindings")
+            with Vertical(id="bindings-list"):
+                for group in binding_help_groups():
+                    with Vertical(classes="binding-group"):
+                        yield Static(group.title, classes="binding-title")
+                        for key, description in group.rows:
+                            with Horizontal(classes="binding-row"):
+                                yield Static(key, classes="binding-key")
+                                yield Static(description, classes="binding-description")
+
+    def action_close(self) -> None:
+        self.dismiss(None)
+
+
+def _fuzzy_score(query: str, candidate: str) -> tuple[int, int, int, int, str] | None:
+    query_lower = query.lower()
+    candidate_lower = candidate.lower()
+    positions: list[int] = []
+    search_from = 0
+    for char in query_lower:
+        index = candidate_lower.find(char, search_from)
+        if index == -1:
+            return None
+        positions.append(index)
+        search_from = index + 1
+
+    first = positions[0]
+    last = positions[-1]
+    spread = last - first + 1
+    gaps = spread - len(query_lower)
+    basename = Path(candidate_lower).name
+    basename_index = candidate_lower.rfind(basename)
+    basename_bonus = 0 if first >= basename_index else 1
+    contiguous_bonus = 0 if query_lower in candidate_lower else 1
+    return (basename_bonus, contiguous_bonus, gaps, len(candidate_lower), candidate_lower)

riched/settings.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+SETTINGS_FILENAME = "settings.yaml"
+
+
+def config_dir() -> Path:
+    if sys.platform == "darwin":
+        return Path("~/Library/Application Support/riched").expanduser()
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        return Path(xdg_config_home).expanduser() / "riched"
+    return Path("~/.config/riched").expanduser()
+
+
+def settings_path() -> Path:
+    return config_dir() / SETTINGS_FILENAME
+
+
+def load_settings() -> dict[str, Any]:
+    path = settings_path()
+    try:
+        data = yaml.safe_load(path.read_text())
+    except Exception:
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return data
+
+
+def load_theme() -> str | None:
+    theme = load_settings().get("theme")
+    return theme if isinstance(theme, str) and theme else None
+
+
+def save_theme(theme: str) -> None:
+    path = settings_path()
+    settings = load_settings()
+    settings["theme"] = theme
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(settings, sort_keys=False))

riched/syntax.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from textual.widgets import TextArea
+
+EXT_LANGUAGE = {
+    ".py": "python",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".json": "json",
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".xml": "xml",
+    ".sql": "sql",
+    ".java": "java",
+    ".go": "go",
+    ".rs": "rust",
+}
+
+_TS_FAMILY_REGISTERED = False
+
+
+def reset_ts_registration() -> None:
+    global _TS_FAMILY_REGISTERED
+    _TS_FAMILY_REGISTERED = False
+
+
+def apply_language(editor: TextArea, suffix: str) -> None:
+    editor.language = None
+    lang = EXT_LANGUAGE.get(suffix.lower())
+    if lang is None:
+        return
+    if lang in ("typescript", "tsx") and not _register_ts_family(editor):
+        lang = "javascript"
+    editor.language = lang
+
+
+def _register_ts_family(editor: TextArea) -> bool:
+    """Register both ``typescript`` and ``tsx`` grammars on the editor."""
+    global _TS_FAMILY_REGISTERED
+    if _TS_FAMILY_REGISTERED:
+        return True
+    try:
+        import tree_sitter_typescript as tsts  # type: ignore
+        from tree_sitter import Language  # type: ignore
+    except Exception:
+        return False
+    try:
+        ts_lang = Language(tsts.language_typescript())
+        tsx_lang = Language(tsts.language_tsx())
+    except Exception:
+        return False
+    try:
+        editor.register_language("typescript", ts_lang, _TS_HIGHLIGHTS)
+        editor.register_language("tsx", tsx_lang, _TS_HIGHLIGHTS + _JSX_HIGHLIGHTS)
+    except Exception:
+        return False
+    _TS_FAMILY_REGISTERED = True
+    return True
+
+
+_TS_HIGHLIGHTS = r"""
+; --- JavaScript base ---------------------------------------------------------
+
+(identifier) @variable
+(property_identifier) @property
+
+(function_expression
+  name: (identifier) @function)
+(function_declaration
+  name: (identifier) @function)
+(method_definition
+  name: (property_identifier) @function.method)
+
+(pair
+  key: (property_identifier) @function.method
+  value: [(function_expression) (arrow_function)])
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: [(function_expression) (arrow_function)])
+
+(variable_declarator
+  name: (identifier) @function
+  value: [(function_expression) (arrow_function)])
+
+(assignment_expression
+  left: (identifier) @function
+  right: [(function_expression) (arrow_function)])
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function.method))
+
+((identifier) @constructor
+ (#match? @constructor "^[A-Z]"))
+
+([
+    (identifier)
+    (shorthand_property_identifier)
+    (shorthand_property_identifier_pattern)
+ ] @constant
+ (#match? @constant "^[A-Z_][A-Z\\d_]+$"))
+
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^(arguments|module|console|window|document)$")
+ (#is-not? local))
+
+((identifier) @function.builtin
+ (#eq? @function.builtin "require")
+ (#is-not? local))
+
+(this) @variable.builtin
+(super) @variable.builtin
+
+[
+  (true)
+  (false)
+  (null)
+  (undefined)
+] @constant.builtin
+
+(comment) @comment
+
+[
+  (string)
+  (template_string)
+] @string
+
+(regex) @string.special
+(number) @number
+
+[
+  ";"
+  (optional_chain)
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "-" "--" "-=" "+" "++" "+=" "*" "*=" "**" "**=" "/" "/=" "%" "%="
+  "<" "<=" "<<" "<<=" "=" "==" "===" "!" "!=" "!==" "=>" ">" ">="
+  ">>" ">>=" ">>>" ">>>=" "~" "^" "&" "|" "^=" "&=" "|=" "&&" "||"
+  "??" "&&=" "||=" "??="
+] @operator
+
+[
+  "(" ")" "[" "]" "{" "}"
+] @punctuation.bracket
+
+(template_substitution
+  "${" @punctuation.special
+  "}" @punctuation.special) @embedded
+
+[
+  "as" "async" "await" "break" "case" "catch" "class" "const" "continue"
+  "debugger" "default" "delete" "do" "else" "export" "extends" "finally"
+  "for" "from" "function" "get" "if" "import" "in" "instanceof" "let"
+  "new" "of" "return" "set" "static" "switch" "target" "throw" "try"
+  "typeof" "var" "void" "while" "with" "yield"
+] @keyword
+
+; --- TypeScript additions ----------------------------------------------------
+
+(type_identifier) @type
+(predefined_type) @type.builtin
+
+((identifier) @type
+ (#match? @type "^[A-Z]"))
+
+(type_arguments
+  "<" @punctuation.bracket
+  ">" @punctuation.bracket)
+
+(required_parameter (identifier) @variable.parameter)
+(optional_parameter (identifier) @variable.parameter)
+
+[ "abstract" "declare" "enum" "implements" "interface" "keyof"
+  "namespace" "private" "protected" "public" "type" "readonly"
+  "override" "satisfies"
+] @keyword
+"""
+
+
+_JSX_HIGHLIGHTS = r"""
+; --- JSX ---------------------------------------------------------------------
+
+(jsx_opening_element
+  ["<" ">"] @punctuation.bracket)
+
+(jsx_closing_element
+  ["</" ">"] @punctuation.bracket)
+
+(jsx_self_closing_element
+  ["<" "/>"] @punctuation.bracket)
+
+(jsx_opening_element
+  name: (identifier) @tag)
+
+(jsx_closing_element
+  name: (identifier) @tag)
+
+(jsx_self_closing_element
+  name: (identifier) @tag)
+
+(jsx_opening_element
+  (member_expression
+    object: (identifier) @tag
+    property: (property_identifier) @tag))
+
+(jsx_closing_element
+  (member_expression
+    object: (identifier) @tag
+    property: (property_identifier) @tag))
+
+(jsx_self_closing_element
+  (member_expression
+    object: (identifier) @tag
+    property: (property_identifier) @tag))
+
+(jsx_attribute
+  (property_identifier) @property)
+
+(jsx_text) @string
+"""
+