ledgerkit-editor 1.0.0__py3-none-any.whl

ledgerkit_editor/__init__.py

@@ -0,0 +1,5 @@
+"""Ledger Editor — a terminal-based plain-text ledger editor built with Textual."""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

ledgerkit_editor/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m ledgerkit_editor`."""
+
+from ledgerkit_editor.app import main
+
+if __name__ == "__main__":
+    main()

ledgerkit_editor/app.py

@@ -0,0 +1,220 @@
+"""Root Textual application for the ledger editor.
+
+Composes the main layout: a file-path bar below the Header, then JournalEditor
+(full-width editing surface). FilterPopup overlays on demand via Ctrl+Shift+P.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+from typing import ClassVar
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.css.query import NoMatches
+from textual.widgets import Footer, Header, Static
+
+from ledgerkit_editor.themes import VALID_THEMES, register_all
+from ledgerkit_editor.themes.monokai_pro import THEME_NAME
+from ledgerkit_editor.utils.file_resolver import resolve_journal_file
+from ledgerkit_editor.widgets.filter_popup import FilterPopup
+from ledgerkit_editor.widgets.transaction_table import JournalEditor
+
+__all__ = ["LedgerApp", "main"]
+
+
+class LedgerApp(App[None]):
+    """Top-level Textual application for the plain-text ledger editor."""
+
+    TITLE = "Ledger Editor"
+    COMMAND_PALETTE_DISPLAY: ClassVar[str] = "Ctrl+P"
+    CSS_PATH = ["themes/monokai_pro.tcss"]
+    BINDINGS = [
+        Binding("ctrl+o", "toggle_filter", "Filter transactions",
+                priority=True, key_display="Ctrl+O"),
+    ]
+    CSS = """
+    Screen {
+        layout: horizontal;
+    }
+    #file-path-bar {
+        dock: top;
+        height: 1;
+        background: $surface;
+        color: $text-muted;
+        padding: 0 1;
+    }
+    JournalEditor {
+        width: 1fr;
+        layout: vertical;
+    }
+    ViewFilterBar {
+        dock: top;
+        height: 1;
+        background: $surface;
+        color: $text-muted;
+        padding: 0 1;
+    }
+    SearchBar {
+        dock: bottom;
+        height: 3;
+        background: $surface;
+        border-top: solid $primary;
+        display: none;
+        layout: horizontal;
+        padding: 0 1;
+    }
+    SearchBar Input {
+        width: 1fr;
+        height: 1;
+        background: $panel;
+        color: $text;
+        border: none;
+    }
+    SearchBar #match-counter {
+        width: auto;
+        padding: 0 1;
+        color: $text-muted;
+    }
+    SearchBar Button {
+        width: auto;
+        min-width: 3;
+        height: 1;
+        border: none;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(
+        self,
+        journal_path: Path,
+        start_line: int | None = None,
+        theme_name: str | None = None,
+    ) -> None:
+        """Initialise the app with a resolved journal file path.
+
+        Args:
+            journal_path: Resolved path to the .journal or .ledger file.
+            start_line: 1-indexed line to place the cursor on after open.
+            theme_name: Registered theme name to activate; defaults to monokai-pro.
+        """
+        super().__init__()
+        self.journal_path = journal_path
+        self._start_line = start_line
+        self._theme_name = theme_name
+
+    def on_mount(self) -> None:
+        """Register bundled themes, activate Monokai Pro, and populate file-path bar."""
+        from ledgerkit_editor.widgets.ledger_textarea import LedgerTextArea  # noqa: PLC0415
+
+        editor = self.query_one(JournalEditor)
+        ledger_textarea = editor.query_one("#journal_textarea", LedgerTextArea)
+        register_all(self, ledger_textarea)
+        if os.environ.get("TEXTUAL_THEME") is None:
+            self.theme = self._theme_name or THEME_NAME
+        self._update_file_path_bar(modified=False)
+
+    def compose(self) -> ComposeResult:
+        """Build the initial widget tree."""
+        yield Header()
+        yield Static("", id="file-path-bar")
+        yield JournalEditor(self.journal_path, start_line=self._start_line)
+        yield Footer()
+
+    def _update_file_path_bar(self, modified: bool) -> None:
+        """Refresh the path bar label, appending '· modified' when unsaved."""
+        path_str = str(Path(self.journal_path).resolve())
+        text = f"{path_str}  ·  modified" if modified else path_str
+        try:
+            self.query_one("#file-path-bar", Static).update(text)
+        except NoMatches:
+            pass
+
+    # ------------------------------------------------------------------
+    # Message handlers
+    # ------------------------------------------------------------------
+
+    def on_journal_editor_file_modified_changed(
+        self, event: JournalEditor.FileModifiedChanged
+    ) -> None:
+        """Update the file-path bar with the modified indicator."""
+        self._update_file_path_bar(modified=event.modified)
+
+    def action_toggle_filter(self) -> None:
+        """Open or close the transaction filter popup (Ctrl+Shift+P)."""
+        existing = self.query(FilterPopup)
+        if existing:
+            existing.first().remove()
+        else:
+            self.mount(FilterPopup())
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    """Parse CLI arguments for the ledger-editor entry point."""
+    raw = list(sys.argv[1:] if argv is None else argv)
+
+    # Extract +N tokens before argparse; it does not handle the bare + prefix.
+    # +N is the traditional $EDITOR convention (vi, emacs) used by shell
+    # scripts and tools that invoke editors via: $EDITOR +N file.
+    #
+    # Purpose: match a bare "+<digits>" token anywhere in argv.
+    # Group 1: the decimal line number.
+    # Edge cases: "+0" matches (clamped to row 0 at use-site); "+N file"
+    #             adjacent to a filename leaves the filename intact.
+    plus_line: int | None = None
+    filtered: list[str] = []
+    for token in raw:
+        m = re.fullmatch(r"\+(\d+)", token)
+        if m:
+            plus_line = int(m.group(1))
+        else:
+            filtered.append(token)
+
+    parser = argparse.ArgumentParser(
+        prog="ledger-editor",
+        description="Terminal-based plain-text ledger editor (hledger format).",
+    )
+    parser.add_argument(
+        "file",
+        nargs="?",
+        metavar="FILE",
+        help="Path to the .journal or .ledger file to edit.",
+    )
+    parser.add_argument(
+        "--line",
+        type=int,
+        metavar="N",
+        default=None,
+        help="Open with cursor at line N (1-indexed). Also accepts +N positional form.",
+    )
+    parser.add_argument(
+        "--theme",
+        metavar="THEME",
+        default=None,
+        choices=sorted(VALID_THEMES),
+        help="Color theme to activate at startup (default: monokai-pro).",
+    )
+    args = parser.parse_args(filtered)
+    # --line takes precedence; +N is the fallback when --line is absent.
+    if args.line is None and plus_line is not None:
+        args.line = plus_line
+    return args
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Entry point wired up in pyproject.toml [project.scripts]."""
+    args = _parse_args(argv)
+    journal_path = resolve_journal_file(args.file)
+    if journal_path is None:
+        print(
+            "No journal file found. Pass a path as an argument, set $LEDGER_FILE, "
+            "or create ~/.hledger.journal.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    app = LedgerApp(journal_path, start_line=args.line, theme_name=args.theme)
+    app.run()

ledgerkit_editor/commands/__init__.py

@@ -0,0 +1,84 @@
+"""Command palette stubs and application-level undo/redo infrastructure."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Optional
+
+__all__ = ["Command", "CommandHistory"]
+
+
+@dataclass
+class Command:
+    """An invertible operation on application or model state.
+
+    Both ``execute`` and ``undo`` must be synchronous callables that complete
+    quickly (< 16 ms).  Heavy work (disk I/O, journal re-parse) must be
+    dispatched via Textual workers by the caller, not inside these callables.
+    """
+
+    execute: Callable[[], None]
+    undo: Callable[[], None]
+    description: str
+    """Short human-readable label shown in notify() on undo/redo."""
+
+
+@dataclass
+class CommandHistory:
+    """Application-level undo/redo stack for operations that affect both buffer
+    text and in-memory model objects.
+
+    This is separate from TextArea's native EditHistory (_undo_stack).  The two
+    stacks are kept in sync by JournalEditor: action_undo / action_redo consult
+    CommandHistory first and fall through to TextArea native undo if it has no
+    entries.
+    """
+
+    _max_size: int = 100
+    _done: list[Command] = field(default_factory=list)
+    _undone: list[Command] = field(default_factory=list)
+
+    def execute(self, cmd: Command) -> None:
+        """Execute a command and push it onto the undo stack."""
+        cmd.execute()
+        self._done.append(cmd)
+        self._undone.clear()
+        if len(self._done) > self._max_size:
+            self._done.pop(0)
+
+    def undo(self) -> Optional[Command]:
+        """Undo the most recent command and move it to the redo stack."""
+        if not self._done:
+            return None
+        cmd = self._done.pop()
+        cmd.undo()
+        self._undone.append(cmd)
+        return cmd
+
+    def redo(self) -> Optional[Command]:
+        """Redo the most recently undone command."""
+        if not self._undone:
+            return None
+        cmd = self._undone.pop()
+        cmd.execute()
+        self._done.append(cmd)
+        return cmd
+
+    @property
+    def can_undo(self) -> bool:
+        """True if there is at least one command on the undo stack."""
+        return bool(self._done)
+
+    @property
+    def can_redo(self) -> bool:
+        """True if there is at least one command on the redo stack."""
+        return bool(self._undone)
+
+
+# TODO: register command palette providers via Textual's CommandPalette API
+# Examples of planned commands:
+#   "Open file"        — resolve_journal_file, reload EditorDocument
+#   "Save"             — trigger action_save
+#   "Filter..."        — open FilterPopup
+#   "Go to account"    — jump cursor to first posting for an account
+#   "Toggle cleared"   — action_toggle_cleared on selection

ledgerkit_editor/highlighting/__init__.py

@@ -0,0 +1,17 @@
+"""Syntax highlighting for hledger journal files.
+
+Provides the LedgerHighlighter (pure-Python scanner), build_textarea_theme
+(CSS-variable bridge), and the token name constants in tokens.py.
+"""
+
+from ledgerkit_editor.highlighting.highlighter import LedgerHighlighter, LineInfo, LineKind
+from ledgerkit_editor.highlighting.theme_bridge import build_textarea_theme
+from ledgerkit_editor.highlighting import tokens
+
+__all__ = [
+    "LedgerHighlighter",
+    "LineInfo",
+    "LineKind",
+    "build_textarea_theme",
+    "tokens",
+]