jnav 1.0.0__py3-none-any.whl

jnav/filter_tree.py

@@ -0,0 +1,344 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar, override
+
+from rich.text import Text
+from textual.binding import Binding, BindingType
+from textual.message import Message
+from textual.widgets import Tree
+from textual.widgets.tree import TreeNode
+
+from jnav.filter_provider import FilterProvider
+from jnav.filtering import (
+    Filter,
+    FilterGroup,
+    FilterNode,
+    build_expression,
+    check_filter_warning,
+)
+from jnav.text_input_screen import TextInputScreen
+
+if TYPE_CHECKING:
+    from textual import getters
+    from textual.app import App
+
+
+@dataclass
+class FilterTreeData:
+    node: FilterNode
+    parent: FilterGroup
+
+
+class FilterTree(Tree[FilterTreeData]):
+    if TYPE_CHECKING:
+        app = getters.app(App[None])
+
+    class Changed(Message):
+        pass
+
+    DEFAULT_CSS = """
+    FilterTree {
+        height: auto;
+        max-height: 14;
+        border: none;
+        background: transparent;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("j", "cursor_down", "Down", show=False),
+        Binding("k", "cursor_up", "Up", show=False),
+        Binding("a", "add_filter", "Add", show=True),
+        Binding("e", "edit_filter", "Edit", show=True),
+        Binding("d", "delete", "Delete", show=True),
+        Binding("t", "toggle_item", "Toggle", show=True),
+        Binding("o", "toggle_combine", "AND/OR", show=True),
+        Binding("n", "toggle_negated", "Negate", show=True),
+        Binding("g", "add_group", "Add group", show=True),
+        Binding("p", "paste", "Paste", show=True),
+        Binding("c", "flatten", "Flatten", show=True),
+        Binding("y", "yank", "Yank", show=True),
+        Binding("r", "rename", "Rename", show=True),
+    ]
+
+    def __init__(
+        self,
+        filter_provider: FilterProvider,
+        *,
+        id: str | None = None,
+    ) -> None:
+        super().__init__("Filters", id=id)
+        self._fp = filter_provider
+        self._clipboard: FilterNode | None = None
+
+    @override
+    def on_mount(self) -> None:
+        self.rebuild()
+
+    def on_tree_node_collapsed(self, event: Tree.NodeCollapsed[FilterTreeData]) -> None:
+        data = event.node.data
+        if data is None:
+            return
+        node = data.node
+        if isinstance(node, FilterGroup):
+            node.collapsed = True
+            event.node.set_label(self._node_label(event.node))
+
+    def on_tree_node_expanded(self, event: Tree.NodeExpanded[FilterTreeData]) -> None:
+        data = event.node.data
+        if data is None:
+            return
+        node = data.node
+        if isinstance(node, FilterGroup):
+            node.collapsed = False
+            event.node.set_label(self._render_label(node))
+
+    def rebuild(self) -> None:
+        saved_line = self.cursor_line
+
+        self.clear()
+        self.root.set_label(self._render_label(self._fp.root))
+        self.root.data = FilterTreeData(node=self._fp.root, parent=self._fp.root)
+        self._populate(self.root, self._fp.root)
+        self.root.expand()
+
+        if self.cursor_line != saved_line:
+            self.cursor_line = min(saved_line, self.last_line)
+        self.post_message(self.Changed())
+
+    def refresh_cursor_node(self) -> None:
+        tree_node = self.cursor_node
+        if tree_node is not None and tree_node.data is not None:
+            tree_node.set_label(self._node_label(tree_node))
+        self.post_message(self.Changed())
+
+    def _node_label(self, tree_node: TreeNode[FilterTreeData]) -> Text:
+        data = tree_node.data
+        assert data is not None
+        node = data.node
+        if isinstance(node, FilterGroup) and not tree_node.is_expanded:
+            style = "" if node.enabled else "dim strike"
+            if node.label:
+                label = Text(node.label, style=f"italic {style}")
+            else:
+                preview = build_expression(
+                    FilterGroup(operator=node.operator, children=node.children)
+                )
+                label = Text(preview, style=style) if preview else None
+            if label is not None:
+                if node.negated:
+                    return Text.assemble(("NOT ", f"bold {style}"), label)
+                return label
+        return self._render_label(node)
+
+    def _populate(
+        self,
+        tree_parent: TreeNode[FilterTreeData],
+        group: FilterGroup,
+    ) -> None:
+        for child in group.children:
+            data = FilterTreeData(node=child, parent=group)
+            label = self._render_label(child)
+            if isinstance(child, FilterGroup):
+                branch = tree_parent.add(label, data=data)
+                self._populate(branch, child)
+                if child.collapsed:
+                    branch.collapse()
+                    branch.set_label(self._node_label(branch))
+                else:
+                    branch.expand()
+            else:
+                tree_parent.add_leaf(label, data=data)
+
+    def _render_label(self, node: FilterNode) -> Text:
+        style = "" if node.enabled else "dim strike"
+        if isinstance(node, FilterGroup):
+            op_hint = (
+                ("", "") if not node.label else (f" ({node.operator.upper()})", "dim")
+            )
+            if node.label:
+                label_style = f"italic {style}"
+                if node.negated:
+                    return Text.assemble(
+                        ("NOT ", f"bold {style}"),
+                        (node.label, label_style),
+                        op_hint,
+                    )
+                return Text.assemble((node.label, label_style), op_hint)
+            if node.negated:
+                op = "NAND" if node.operator == "and" else "NOR"
+            else:
+                op = node.operator.upper()
+            return Text(op, style=style)
+
+        if node.label:
+            display_style = f"italic {style}"
+            display = node.label
+        else:
+            display_style = style
+            display = node.expr
+        if node.negated:
+            return Text.assemble(("NOT ", f"bold {style}"), (display, display_style))
+        return Text(display, style=display_style)
+
+    def _cursor_data(self) -> FilterTreeData | None:
+        node = self.cursor_node
+        if node is None or node.data is None:
+            return None
+        return node.data
+
+    def _insert_at_cursor(self) -> tuple[FilterGroup, int | None]:
+        data = self._cursor_data()
+        if data is not None:
+            cursor_node = data.node
+            parent = data.parent
+            if isinstance(cursor_node, FilterGroup):
+                return (cursor_node, None)
+            return (parent, parent.children.index(cursor_node))
+        return (self._fp.root, None)
+
+    async def action_toggle_item(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        await self._fp.toggle_node(data.node)
+        self.refresh_cursor_node()
+
+    async def action_toggle_negated(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        await self._fp.toggle_negated(data.node)
+        self.refresh_cursor_node()
+
+    async def action_add_group(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        node = data.node
+        parent = data.parent
+        if isinstance(node, FilterGroup):
+            await self._fp.add_group(node)
+        else:
+            idx = parent.children.index(node)
+            await self._fp.add_group(parent, idx)
+        self.rebuild()
+
+    async def action_toggle_combine(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        if not isinstance(data.node, FilterGroup):
+            return
+        await self._fp.set_node_operator(data.node, data.parent)
+        self.rebuild()
+
+    def action_yank(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        node = data.node
+        if node is self._fp.root:
+            return
+        self._clipboard = node.model_copy(deep=True)
+
+    async def action_flatten(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        node = data.node
+        if not isinstance(node, FilterGroup) or node is self._fp.root:
+            return
+        await self._fp.flatten_group(node, data.parent)
+        self.rebuild()
+
+    async def action_delete(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        node = data.node
+        if node is self._fp.root:
+            return
+        self._clipboard = node
+        await self._fp.remove_node(node, data.parent)
+        self.rebuild()
+
+    async def action_paste(self) -> None:
+        if self._clipboard is None:
+            return
+        parent, idx = self._insert_at_cursor()
+        if idx is not None:
+            parent.children.insert(idx + 1, self._clipboard)
+        else:
+            parent.children.append(self._clipboard)
+        self._clipboard = None
+        await self._fp.on_change.asend(None)
+        self.rebuild()
+
+    def action_add_filter(self) -> None:
+        target = self._insert_at_cursor()
+
+        async def on_dismiss(expr: str | None) -> None:
+            if not expr:
+                return
+            warning = check_filter_warning(expr)
+            parent, idx = target
+            leaf = Filter(expr=expr)
+            if idx is not None:
+                parent.children.insert(idx + 1, leaf)
+            else:
+                parent.children.append(leaf)
+            await self._fp.on_change.asend(None)
+            self.rebuild()
+            if warning:
+                self.app.notify(warning, severity="warning", timeout=3)
+
+        self.app.push_screen(
+            TextInputScreen("Add filter", placeholder="jq expression..."),
+            on_dismiss,
+        )
+
+    def action_edit_filter(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        node = data.node
+        if not isinstance(node, Filter):
+            return
+
+        async def on_dismiss(expr: str | None) -> None:
+            if not expr:
+                return
+            warning = check_filter_warning(expr)
+            await self._fp.edit_leaf(node, expr)
+            self.rebuild()
+            if warning:
+                self.app.notify(warning, severity="warning", timeout=3)
+
+        self.app.push_screen(
+            TextInputScreen(
+                "Edit filter",
+                placeholder="jq expression...",
+                initial_value=node.expr,
+            ),
+            on_dismiss,
+        )
+
+    def action_rename(self) -> None:
+        data = self._cursor_data()
+        if data is None:
+            return
+        node = data.node
+
+        async def on_dismiss(label: str | None) -> None:
+            node.label = label
+            await self._fp.on_change.asend(None)
+            self.rebuild()
+
+        self.app.push_screen(
+            TextInputScreen(
+                "Rename",
+                placeholder="label...",
+                initial_value=node.label or "",
+            ),
+            on_dismiss,
+        )

jnav/filtering.py

@@ -0,0 +1,191 @@
+import functools
+import json
+import math
+import re
+from collections.abc import Sequence
+from typing import Annotated, Any, Literal, cast
+
+import jq
+from pydantic import BaseModel, Discriminator, Field
+
+
+class Filter(BaseModel):
+    type: Literal["leaf"] = "leaf"
+    expr: str
+    enabled: bool = True
+    negated: bool = False
+    label: str | None = None
+
+
+class FilterGroup(BaseModel):
+    type: Literal["group"] = "group"
+    operator: Literal["and", "or"] = "and"
+    enabled: bool = True
+    negated: bool = False
+    label: str | None = None
+    collapsed: bool = False
+    children: list[FilterNode] = Field(default_factory=list)
+
+
+FilterNode = Annotated[Filter | FilterGroup, Discriminator("type")]
+
+FilterGroup.model_rebuild()
+
+
+@functools.lru_cache(maxsize=32)
+def _compile_jq(expression: str):
+    return jq.compile(expression)
+
+
+def apply_jq_filter(
+    expression: str,
+    entries: list[dict[str, Any]],
+) -> tuple[list[int], str | None]:
+    try:
+        prog = _compile_jq(expression)
+    except ValueError as e:
+        return [], str(e)
+    matched: list[int] = []
+    for i, entry in enumerate(entries):
+        try:
+            results = prog.input_value(entry).all()
+            if any(r is not None and r is not False for r in results):
+                matched.append(i)
+        except ValueError:
+            continue
+    return matched, None
+
+
+def build_expression(node: FilterNode) -> str | None:
+    """Recursively build a jq expression from a filter tree.
+
+    Returns None if the node is disabled or has no effective children.
+    """
+    if not node.enabled:
+        return None
+
+    if isinstance(node, Filter):
+        expr = node.expr
+        if node.negated:
+            expr = f"{expr} | not"
+        return expr
+
+    child_exprs: list[tuple[str, FilterNode]] = []
+    for child in node.children:
+        child_expr = build_expression(child)
+        if child_expr is not None:
+            child_exprs.append((child_expr, child))
+
+    if not child_exprs:
+        return None
+
+    if len(child_exprs) == 1:
+        result = child_exprs[0][0]
+    else:
+        joiner = f" {node.operator} "
+        wrapped: list[str] = []
+        for expr, child in child_exprs:
+            needs_parens = "|" in expr or (
+                isinstance(child, FilterGroup)
+                and len(child.children) > 1
+                and child.operator != node.operator
+            )
+            wrapped.append(f"({expr})" if needs_parens else expr)
+        result = joiner.join(wrapped)
+
+    if node.negated:
+        result = f"({result}) | not"
+
+    return result
+
+
+def apply_filter_tree(
+    root: FilterGroup,
+    entries: list[dict[str, Any]],
+) -> tuple[list[int], str | None]:
+    """Apply a filter tree to a list of entries."""
+    combined = build_expression(root)
+    if combined is None:
+        return list(range(len(entries))), None
+    return apply_jq_filter(combined, entries)
+
+
+def text_search_expr(term: str) -> str:
+    escaped = term.lower().replace("\\", "\\\\").replace('"', '\\"')
+    return f'[.. | strings] | any(ascii_downcase | contains("{escaped}"))'
+
+
+_ASSIGNMENT_RE = re.compile(r"(?<![=!<>])=(?!=)")
+_STRING_LITERAL_RE = re.compile(r'"[^"\\]*(?:\\.[^"\\]*)*"')
+
+
+def check_filter_warning(expression: str) -> str | None:
+    without_strings = _STRING_LITERAL_RE.sub('""', expression)
+    if _ASSIGNMENT_RE.search(without_strings):
+        return "jq update operators don't filter. Did you mean a comparison like '=='?"
+    return None
+
+
+def get_nested(entry: dict[str, Any], path: str) -> object:
+    try:
+        results = _compile_jq(path).input_value(entry).all()
+    except ValueError:
+        return None
+    if len(results) == 1:
+        return results[0]
+    return results
+
+
+def jq_value_literal(value: object) -> str:
+    if isinstance(value, str):
+        return json.dumps(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return "null"
+    if isinstance(value, (int, float)):
+        if not math.isfinite(value):
+            raise ValueError(f"jq does not support {value!r}")
+        return str(value)
+    return json.dumps(value)
+
+
+def _jq_path_to_str(parts: Sequence[str | int]) -> str:
+    result = ""
+    for p in parts:
+        if isinstance(p, int):
+            result += f"[{p}]"
+        else:
+            result = f"{result}.{p}" if result else p
+    return result
+
+
+def resolve_selected_paths(columns: set[str], entry: dict[str, Any]) -> set[str]:
+    """Expand jq column expressions into concrete paths for a specific entry."""
+    result: set[str] = set()
+    for col in columns:
+        if "[]" not in col and "|" not in col:
+            result.add(col.lstrip("."))
+            continue
+        jq_path = col
+        try:
+            raw = jq.compile(f"[path({jq_path})]").input_value(entry).first()
+            for parts in raw:
+                result.add(_jq_path_to_str(parts))
+            continue
+        except ValueError:
+            pass
+        try:
+            results = jq.compile(jq_path).input_value(entry).all()
+            base_expr = jq_path.split("|")[0].strip()
+            raw_bases = jq.compile(f"[path({base_expr})]").input_value(entry).first()
+            for base_parts in raw_bases:
+                base = _jq_path_to_str(base_parts)
+                for r in results:
+                    if isinstance(r, dict):
+                        r = cast(dict[str, object], r)
+                        for key in r:
+                            result.add(f"{base}.{key}")
+        except ValueError:
+            result.add(col)
+    return result

jnav/header.py

@@ -0,0 +1,48 @@
+from typing import ClassVar, override
+
+from rich.text import Text
+from textual.widgets import Static
+
+
+class Header(Static):
+    COMPONENT_CLASSES: ClassVar[set[str]] = {
+        "header--bracket",
+        "header--text",
+        "header--file",
+    }
+
+    DEFAULT_CSS = """
+    Header {
+        height: 1;
+        background: $surface;
+    }
+    Header > .header--bracket {
+        color: $accent;
+        text-style: bold;
+    }
+    Header > .header--text {
+        color: $foreground;
+        text-style: bold;
+    }
+    Header > .header--file {
+        color: $text-muted;
+        text-style: italic;
+    }
+    """
+
+    def __init__(self, file_name: str) -> None:
+        super().__init__()
+        self._file_name = file_name
+
+    @override
+    def render(self) -> Text:
+        bracket = self.get_component_rich_style("header--bracket")
+        text = self.get_component_rich_style("header--text")
+        file_name = self.get_component_rich_style("header--file")
+        return Text.assemble(
+            ("[", bracket),
+            ("J", text),
+            ("]", bracket),
+            ("NAV", text),
+            (f" {self._file_name}", file_name),
+        )

jnav/help_screen.py

@@ -0,0 +1,79 @@
+from typing import ClassVar, override
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+HELP_TEXT = """\
+[b]Navigation[/b]
+  [b]j/k[/b]       Cursor down/up
+  [b]gg/G[/b]      Jump to top/bottom
+  [b]Ctrl+D/U[/b]  Half-page down/up
+  [b]h/l[/b]       Focus list/detail
+  [b]Enter[/b]     Inspect entry
+  [b]Escape[/b]    Back
+
+[b]Actions[/b]
+  [b]/[/b]         Search
+  [b]n/N[/b]       Next/prev match
+  [b]F[/b]         Filter manager
+  [b]ft[/b]        Text filter
+  [b]fp[/b]        Pause/resume filters
+  [b]S[/b]         Selected fields manager
+  [b]vi[/b]        Toggle inline expanded tree
+  [b]d[/b]         Toggle detail panel
+  [b]r[/b]         Reset filters, fields, search
+  [b]?[/b]         This help
+  [b]q[/b]         Quit
+
+[b]Detail Panel[/b]
+  [b]ff[/b]        Filter by value
+  [b]fn[/b]        Has field
+  [b]s[/b]         (Un)select field
+  [b]ve[/b]        View value in $EDITOR
+  [b]vo[/b]        Show selected fields only
+"""
+
+
+class HelpScreen(ModalScreen[bool]):
+    DEFAULT_CSS = """
+    HelpScreen {
+        align: center middle;
+    }
+    #help-modal {
+        width: 55;
+        max-width: 90%;
+        height: auto;
+        max-height: 80%;
+        border: round $surface-lighten-2;
+        background: $surface;
+        padding: 1 2;
+    }
+    #help-hints {
+        color: $text-muted;
+        padding: 1 0 0 0;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "close", "Close", priority=True),
+        Binding("q", "close", show=False),
+        Binding("ctrl+c", "close", show=False),
+        Binding("question_mark", "close", show=False),
+    ]
+
+    @override
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Static(HELP_TEXT),
+            Static("[b]esc[/b] or [b]?[/b] to close", id="help-hints"),
+            id="help-modal",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#help-modal").border_title = "Keybindings"
+
+    def action_close(self) -> None:
+        self.dismiss(True)