sniplab 0.3.2

A filesystem-native snippet library and agent-friendly CLI, installed as `snip`
Documentation
use super::super::editor::{EditOutcome, EditRequest, EditTarget};
use super::super::modal::{ConfirmModal, Modal, ModalAction};
use super::super::state::StatusLevel;
use super::types::{App, Effect};

impl App {
    pub fn handle_editor_outcome(&mut self, outcome: EditOutcome) {
        match outcome {
            EditOutcome::Unchanged => {
                self.set_status("editor closed without changes", StatusLevel::Info)
            }
            EditOutcome::Saved => {
                if let Err(error) = self.rescan() {
                    self.set_status(error.to_string(), StatusLevel::Error);
                } else {
                    self.set_status("snippet saved", StatusLevel::Info);
                }
            }
            EditOutcome::Conflict(request) => {
                self.modal = Some(Modal::Confirm(ConfirmModal::new(
                    "Overwrite changed snippet?",
                    "The snippet changed on disk while the editor was open.",
                    ModalAction::ForceEdit(request),
                    true,
                )));
            }
        }
    }

    pub(super) fn edit_effect(&mut self) -> Vec<Effect> {
        let Some(snippet) = self.selected_snippet() else {
            return Vec::new();
        };
        if snippet.locked {
            self.set_status(
                "snippet is locked; use the CLI with --force",
                StatusLevel::Error,
            );
            return Vec::new();
        }
        let Some(fragment) = snippet.loaded_fragments.get(self.fragment_index) else {
            return Vec::new();
        };
        let suffix = std::path::Path::new(&fragment.file)
            .extension()
            .and_then(|value| value.to_str())
            .unwrap_or("txt")
            .to_owned();
        vec![Effect::SpawnEditor(EditRequest {
            snippet_id: snippet.id,
            target: EditTarget::Content {
                fragment_id: fragment.id,
            },
            expected: snippet.fingerprint.clone(),
            original: fragment.content.clone(),
            edited: None,
            suffix,
        })]
    }

    pub(super) fn edit_note_effect(&mut self) -> Vec<Effect> {
        let Some(snippet) = self.mutable_selected() else {
            return Vec::new();
        };
        let Some(fragment) = snippet.loaded_fragments.get(self.fragment_index) else {
            return Vec::new();
        };
        vec![Effect::SpawnEditor(EditRequest {
            snippet_id: snippet.id,
            target: EditTarget::Note {
                fragment_id: fragment.id,
            },
            expected: snippet.fingerprint.clone(),
            original: fragment.note_content.clone().unwrap_or_default(),
            edited: None,
            suffix: "md".to_owned(),
        })]
    }

    pub(super) fn edit_readme_effect(&mut self) -> Vec<Effect> {
        let Some(snippet) = self.mutable_selected() else {
            return Vec::new();
        };
        vec![Effect::SpawnEditor(EditRequest {
            snippet_id: snippet.id,
            target: EditTarget::Readme,
            expected: snippet.fingerprint.clone(),
            original: snippet.readme.clone().unwrap_or_default(),
            edited: None,
            suffix: "md".to_owned(),
        })]
    }

    pub(super) fn copy_content_effect(&self) -> Vec<Effect> {
        self.selected_snippet()
            .and_then(|snippet| snippet.loaded_fragments.get(self.fragment_index))
            .map(|fragment| Effect::CopyToClipboard {
                text: fragment.content.clone(),
                label: "fragment".to_owned(),
            })
            .into_iter()
            .collect()
    }

    pub(super) fn copy_id_effect(&self) -> Vec<Effect> {
        self.selected_snippet()
            .map(|snippet| Effect::CopyToClipboard {
                text: snippet.id.to_string(),
                label: "snippet ID".to_owned(),
            })
            .into_iter()
            .collect()
    }

    pub(super) fn copy_path_effect(&self) -> Vec<Effect> {
        self.selected_snippet()
            .map(|snippet| {
                let path = snippet
                    .loaded_fragments
                    .get(self.fragment_index)
                    .map(|fragment| &fragment.absolute_path)
                    .unwrap_or(&snippet.package_path);
                Effect::CopyToClipboard {
                    text: path.display().to_string(),
                    label: "snippet path".to_owned(),
                }
            })
            .into_iter()
            .collect()
    }

    pub(super) fn open_vscode_effect(&self) -> Vec<Effect> {
        self.selected_snippet()
            .map(|snippet| {
                let path = snippet
                    .loaded_fragments
                    .get(self.fragment_index)
                    .map(|fragment| fragment.absolute_path.clone())
                    .unwrap_or_else(|| snippet.package_path.clone());
                Effect::OpenInVsCode { path }
            })
            .into_iter()
            .collect()
    }
}