lattice_snippet/

picker_sources.rs

//! `:picker snippets` source generator.
//!
//! Walks the live `SnippetRegistry` for the active buffer's
//! language and emits one row per registered snippet. Accept
//! emits a `PickerAcceptOutcome::ExpandSnippet { id }` which
//! the host resolves through `App::expand_snippet_by_name`
//! -- the same path `:snippet-expand <name>` uses, so cursor
//! placement / tab-stops / mark insertion all match the
//! keyboard-driven flow.
//!
//! `SnippetRegistry` lives in this crate; the source lives
//! here too so the dependency direction stays
//! `lattice-snippet -> lattice-picker` (cycle-free; the
//! picker crate is renderer- and feature-agnostic).

use std::sync::Arc;

use arc_swap::ArcSwap;
use lattice_completion::{Annotation, CandidateKind, RawCandidate};
use lattice_picker::{
    PickerAcceptOutcome, PickerContext, PickerInitResult, PickerSourceGenerator, PickerSourceSpec,
    RoutingPayload, SourceResult,
};

use crate::registry::{SnippetMeta, SnippetRegistry};

/// MP.2: the marginalia for one snippet row — the name as a `Kind`
/// label cell, and (when present) the description as a `DocSnippet`.
/// The prefix stays the matchable `display`, so it carries no
/// annotation. Single home so source + test agree on the set.
fn snippet_annotations(meta: &SnippetMeta) -> Vec<Annotation> {
    let mut annotations = vec![Annotation::Kind(meta.name.clone().into())];
    if let Some(desc) = meta.description.as_deref().filter(|d| !d.is_empty()) {
        annotations.push(Annotation::DocSnippet(desc.into()));
    }
    annotations
}

/// `:picker snippets`. Walks
/// `SnippetRegistry::meta_for_language(active_lang)` and
/// emits one row per snippet, displayed as `prefix  name --
/// description`.
pub struct SnippetsSource {
    pub spec: PickerSourceSpec,
    pub registry: Arc<ArcSwap<SnippetRegistry>>,
}

impl SnippetsSource {
    pub fn new(registry: Arc<ArcSwap<SnippetRegistry>>) -> Self {
        Self {
            spec: PickerSourceSpec::no_args(
                "snippets",
                "Available snippets for the active buffer's language. `<CR>` expands the chosen snippet at the cursor.",
            ),
            registry,
        }
    }
}

impl PickerSourceGenerator for SnippetsSource {
    fn spec(&self) -> &PickerSourceSpec {
        &self.spec
    }

    fn init(&self, ctx: &PickerContext<'_>, _args: &[String]) -> SourceResult<PickerInitResult> {
        let language = ctx.active_buffer.language.unwrap_or("plain");
        let snapshot = self.registry.load();
        let mut metas = snapshot.meta_for_language(language);
        if metas.is_empty() {
            return Err(format!(
                "snippets: no snippets registered for language `{language}`"
            ));
        }
        // Sort by user-facing prefix so popup order is stable.
        metas.sort_by(|a, b| a.prefix.cmp(&b.prefix));
        // MP.2: the prefix (the trigger the user types) is the matchable
        // `display`; the snippet name and description become typed
        // marginalia (`Kind` + `DocSnippet`) — `AnnotationColumns` owns
        // alignment, so no hand-padding.
        let pairs = metas
            .into_iter()
            .map(|meta| {
                let mut cand = RawCandidate::plain(meta.prefix.clone(), CandidateKind::Plain);
                cand.annotations = snippet_annotations(&meta);
                // ExpandSnippet routing carries the snippet
                // `name` (stable id) -- the host resolves the
                // body through `SnippetRegistry::by_name` at
                // expansion time. Identity for MRU is the
                // name, so frequent-snippet rows float.
                (
                    cand,
                    RoutingPayload::ExpandSnippet {
                        id: meta.name.clone(),
                    },
                )
            })
            .collect();
        Ok(PickerInitResult::Inline(pairs))
    }

    fn accept(
        &self,
        _ctx: &PickerContext<'_>,
        routing: &RoutingPayload,
    ) -> SourceResult<PickerAcceptOutcome> {
        match routing {
            RoutingPayload::ExpandSnippet { id } => {
                Ok(PickerAcceptOutcome::ExpandSnippet { id: id.clone() })
            }
            other => Err(format!("snippets: unexpected routing payload {other:?}")),
        }
    }
}

/// Register this crate's picker sources into the supplied
/// registry. Called by the host's `App::new` at boot:
///
/// ```ignore
/// lattice_snippet::picker_sources::register(&mut picker_registry, snippet_registry);
/// ```
///
/// New feature crates that ship picker sources follow this
/// pattern (see also `lattice-lsp::picker_sources::register`).
pub fn register(
    picker_registry: &mut lattice_picker::PickerRegistry,
    snippet_registry: Arc<ArcSwap<SnippetRegistry>>,
) {
    picker_registry.register_generator(Arc::new(SnippetsSource::new(snippet_registry)));
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used, clippy::panic)]

    use super::*;

    /// P.10: empty-registry returns `Err` so the picker stays
    /// closed with a clean echo. End-to-end behavior over
    /// the App's wired registry is covered by the host-side
    /// tests; this fixture validates the source's error path
    /// without depending on the full snippet parser.
    #[test]
    fn snippets_source_empty_language_errors() {
        let registry = Arc::new(ArcSwap::from_pointee(SnippetRegistry::new()));
        let source = SnippetsSource::new(registry);
        // Build a minimal stand-in PickerContext. We can't
        // easily construct one without the host's
        // `build_picker_context`; the spec-only assertion
        // below covers the trait shape, and the host-side
        // tests in lattice-ui-tui exercise end-to-end.
        assert_eq!(source.spec().id, "snippets");
        assert!(source.spec().args_schema.is_empty());
    }

    /// MP.2: a snippet row's marginalia is a `Kind` name cell plus a
    /// `DocSnippet` description cell; the prefix stays the matchable
    /// display (no annotation). A description-less snippet emits only
    /// the name cell.
    #[test]
    fn snippet_annotations_name_and_description() {
        let with_desc = SnippetMeta {
            name: "for-loop".into(),
            prefix: "for".into(),
            description: Some("C-style for loop".into()),
        };
        let anns = snippet_annotations(&with_desc);
        assert_eq!(anns.len(), 2);
        assert_eq!(anns[0].category(), "kind");
        assert_eq!(anns[0].display_text(), "for-loop");
        assert_eq!(anns[1].category(), "doc");
        assert_eq!(anns[1].display_text(), "C-style for loop");

        let no_desc = SnippetMeta {
            name: "main".into(),
            prefix: "main".into(),
            description: None,
        };
        let anns = snippet_annotations(&no_desc);
        assert_eq!(anns.len(), 1);
        assert_eq!(anns[0].category(), "kind");
    }
}