sniplab 0.3.2

A filesystem-native snippet library and agent-friendly CLI, installed as `snip`
Documentation
use std::fs;
use std::path::Path;
use std::process::Command;

use tempfile::Builder;
use uuid::Uuid;

use crate::domain::Fingerprint;
use crate::error::{ErrorKind, Result, SnipError};
use crate::filesystem::Library;
use crate::service::{EditOptions, edit_snippet};

#[derive(Clone, Debug)]
pub struct EditRequest {
    pub snippet_id: Uuid,
    pub target: EditTarget,
    pub expected: Fingerprint,
    pub original: String,
    pub edited: Option<String>,
    pub suffix: String,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum EditTarget {
    Content { fragment_id: Uuid },
    Note { fragment_id: Uuid },
    Readme,
}

#[derive(Debug)]
pub enum EditOutcome {
    Unchanged,
    Saved,
    Conflict(EditRequest),
}

pub fn run_external_edit(
    library: &Library,
    mut request: EditRequest,
    configured_editor: Option<&str>,
) -> Result<EditOutcome> {
    let suffix = if request.suffix.starts_with('.') {
        request.suffix.clone()
    } else {
        format!(".{}", request.suffix)
    };
    let mut temp = Builder::new()
        .suffix(&suffix)
        .tempfile()
        .map_err(|error| SnipError::io(format!("cannot create temporary editor file: {error}")))?;
    std::io::Write::write_all(&mut temp, request.original.as_bytes())?;
    launch_editor(temp.path(), configured_editor)?;
    let edited = fs::read_to_string(temp.path()).map_err(|error| {
        SnipError::io(format!(
            "cannot read editor result {}: {error}",
            temp.path().display()
        ))
    })?;
    if edited == request.original {
        return Ok(EditOutcome::Unchanged);
    }
    request.edited = Some(edited.clone());
    match save(library, &request, false) {
        Ok(()) => Ok(EditOutcome::Saved),
        Err(error) if error.kind == ErrorKind::Conflict => Ok(EditOutcome::Conflict(request)),
        Err(error) => Err(error),
    }
}

pub fn force_save(library: &Library, request: &EditRequest) -> Result<()> {
    save(library, request, true)
}

fn save(library: &Library, request: &EditRequest, force: bool) -> Result<()> {
    let edited = request
        .edited
        .as_ref()
        .ok_or_else(|| SnipError::usage("edited content is unavailable"))?;
    let mut options = EditOptions {
        if_hash: (!force).then(|| request.expected.clone()),
        force,
        ..EditOptions::default()
    };
    match &request.target {
        EditTarget::Content { fragment_id } => {
            options.fragment_selector = Some(fragment_id.to_string());
            options.content = Some(edited.clone());
        }
        EditTarget::Note { fragment_id } => {
            options.fragment_selector = Some(fragment_id.to_string());
            options.note = Some(Some(edited.clone()));
        }
        EditTarget::Readme => options.readme = Some(Some(edited.clone())),
    }
    edit_snippet(library, &request.snippet_id.to_string(), &options)?;
    Ok(())
}

fn launch_editor(path: &Path, configured_editor: Option<&str>) -> Result<()> {
    let editor = configured_editor.map(ToOwned::to_owned).unwrap_or_else(|| {
        std::env::var("VISUAL")
            .or_else(|_| std::env::var("EDITOR"))
            .unwrap_or_else(|_| "vi".to_owned())
    });
    let parts = shlex::split(&editor)
        .filter(|parts| !parts.is_empty())
        .ok_or_else(|| SnipError::usage(format!("invalid editor command: {editor:?}")))?;
    let status = Command::new(&parts[0])
        .args(&parts[1..])
        .arg(path)
        .status()
        .map_err(|error| SnipError::io(format!("cannot start editor: {error}")))?;
    if status.success() {
        Ok(())
    } else {
        Err(SnipError::io(format!("editor exited with status {status}")))
    }
}