sniplab 0.3.2

A filesystem-native snippet library and agent-friendly CLI, installed as `snip`
Documentation
use std::collections::HashMap;

use crate::domain::CatalogSnapshot;

use super::state::{SidebarItem, SidebarRow, SidebarState};

pub fn rebuild(state: &mut SidebarState, catalog: &CatalogSnapshot, trash_count: usize) {
    let selected_key = state.selected().map(row_key);
    if state.expanded.is_empty() {
        state.expanded.extend(catalog.folders.iter().cloned());
    }

    let uncategorized_count = catalog
        .snippets
        .iter()
        .filter(|snippet| snippet.folder.is_empty())
        .count();

    let mut rows = vec![
        SidebarRow {
            item: SidebarItem::All,
            label: "All snippets".to_owned(),
            depth: 0,
            count: catalog.snippets.len(),
            has_children: false,
            expanded: false,
        },
        SidebarRow {
            item: SidebarItem::Uncategorized,
            label: "Uncategorized".to_owned(),
            depth: 0,
            count: uncategorized_count,
            has_children: false,
            expanded: false,
        },
    ];

    if !catalog.folders.is_empty() {
        rows.push(SidebarRow {
            item: SidebarItem::Header,
            label: "Folders".to_owned(),
            depth: 0,
            count: 0,
            has_children: false,
            expanded: false,
        });

        for folder in &catalog.folders {
            if !ancestors_visible(folder, &state.expanded) {
                continue;
            }
            let prefix = format!("{folder}/");
            let has_children = catalog
                .folders
                .iter()
                .any(|candidate| candidate.starts_with(&prefix));
            let count = catalog
                .snippets
                .iter()
                .filter(|snippet| snippet.folder == *folder || snippet.folder.starts_with(&prefix))
                .count();
            rows.push(SidebarRow {
                item: SidebarItem::Folder(folder.clone()),
                label: folder.rsplit('/').next().unwrap_or(folder).to_owned(),
                depth: folder.matches('/').count(),
                count,
                has_children,
                expanded: state.expanded.contains(folder),
            });
        }
    }

    rows.push(SidebarRow {
        item: SidebarItem::Trash,
        label: "Trash".to_owned(),
        depth: 0,
        count: trash_count,
        has_children: false,
        expanded: false,
    });

    rows.push(SidebarRow {
        item: SidebarItem::Header,
        label: "Tags".to_owned(),
        depth: 0,
        count: 0,
        has_children: false,
        expanded: false,
    });
    let tag_counts = catalog
        .tags
        .iter()
        .map(|tag| {
            let count = catalog
                .snippets
                .iter()
                .filter(|snippet| {
                    snippet
                        .tags
                        .iter()
                        .any(|candidate| candidate.eq_ignore_ascii_case(tag))
                })
                .count();
            (tag.to_lowercase(), count)
        })
        .collect::<HashMap<_, _>>();
    for tag in &catalog.tags {
        rows.push(SidebarRow {
            item: SidebarItem::Tag(tag.clone()),
            label: tag.clone(),
            depth: 0,
            count: *tag_counts.get(&tag.to_lowercase()).unwrap_or(&0),
            has_children: false,
            expanded: false,
        });
    }

    state.rows = rows;
    let selection = selected_key
        .and_then(|key| state.rows.iter().position(|row| row_key(row) == key))
        .or_else(|| {
            state
                .list_state
                .selected()
                .map(|index| index.min(state.rows.len().saturating_sub(1)))
        });
    state.list_state.select(selection);
    if state.list_state.selected().is_none() {
        state.select_first_actionable();
    }
}

fn row_key(row: &SidebarRow) -> String {
    match &row.item {
        SidebarItem::All => "all".to_owned(),
        SidebarItem::Uncategorized => "uncategorized".to_owned(),
        SidebarItem::Folder(path) => format!("folder:{path}"),
        SidebarItem::Trash => "trash".to_owned(),
        SidebarItem::Tag(tag) => format!("tag:{tag}"),
        SidebarItem::Header => "header".to_owned(),
    }
}

fn ancestors_visible(folder: &str, expanded: &std::collections::BTreeSet<String>) -> bool {
    let components = folder.split('/').collect::<Vec<_>>();
    (1..components.len()).all(|end| expanded.contains(&components[..end].join("/")))
}