servicenow-cli 0.6.3

Fast, safe, human-friendly ServiceNow operations from the terminal
Documentation
use std::path::{Path, PathBuf};

use crate::api::ApiError;

pub const LIST_FIELDS: &[&str] = &[
    "file_name",
    "content_type",
    "size_bytes",
    "sys_created_by",
    "sys_created_on",
    "sys_id",
];

pub fn upload_file_name(path: &Path, override_name: Option<&str>) -> Result<String, ApiError> {
    let name = override_name
        .map(str::trim)
        .filter(|name| !name.is_empty())
        .map(str::to_string)
        .or_else(|| {
            path.file_name()
                .and_then(|name| name.to_str())
                .map(str::to_string)
        })
        .ok_or_else(|| {
            ApiError::InvalidInput(
                "could not derive an attachment name; provide --name explicitly".into(),
            )
        })?;
    validate_file_name(&name)?;
    Ok(name)
}

pub fn safe_download_name(name: &str) -> Result<String, ApiError> {
    let name = name
        .rsplit(['/', '\\'])
        .next()
        .map(str::trim)
        .unwrap_or_default();
    validate_file_name(name)?;
    Ok(name.to_string())
}

pub fn destination_path(destination: Option<&Path>, file_name: &str) -> Result<PathBuf, ApiError> {
    let safe_name = safe_download_name(file_name)?;
    match destination {
        None => Ok(PathBuf::from(safe_name)),
        Some(path) if path == Path::new("-") => Ok(path.to_path_buf()),
        Some(path) if path.is_dir() => Ok(path.join(safe_name)),
        Some(path) => Ok(path.to_path_buf()),
    }
}

pub fn content_type(path: &Path, explicit: Option<&str>) -> Result<String, ApiError> {
    if let Some(value) = explicit.map(str::trim).filter(|value| !value.is_empty()) {
        reqwest::header::HeaderValue::from_str(value)
            .map_err(|_| ApiError::InvalidInput(format!("invalid HTTP content type '{value}'")))?;
        return Ok(value.to_string());
    }
    Ok(mime_guess::from_path(path)
        .first_or_octet_stream()
        .essence_str()
        .to_string())
}

pub fn human_size(value: &str) -> String {
    let Ok(bytes) = value.parse::<u64>() else {
        return value.to_string();
    };
    const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
    let mut size = bytes as f64;
    let mut unit = 0usize;
    while size >= 1024.0 && unit < UNITS.len() - 1 {
        size /= 1024.0;
        unit += 1;
    }
    if unit == 0 {
        format!("{bytes} B")
    } else {
        format!("{size:.1} {}", UNITS[unit])
    }
}

fn validate_file_name(name: &str) -> Result<(), ApiError> {
    if name.is_empty()
        || matches!(name, "." | "..")
        || name.contains(['/', '\\', '\0'])
        || name.chars().any(char::is_control)
    {
        Err(ApiError::InvalidInput(format!(
            "invalid attachment file name '{name}'"
        )))
    } else {
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn download_names_cannot_escape_the_destination() {
        assert_eq!(
            safe_download_name("../../report.txt").unwrap(),
            "report.txt"
        );
        assert_eq!(safe_download_name(r"..\report.txt").unwrap(), "report.txt");
        assert!(safe_download_name("..").is_err());
        assert!(safe_download_name("\0").is_err());
    }

    #[test]
    fn destination_uses_server_name_for_directories() {
        let directory = tempfile::tempdir().unwrap();
        assert_eq!(
            destination_path(Some(directory.path()), "report.txt").unwrap(),
            directory.path().join("report.txt")
        );
        assert_eq!(
            destination_path(Some(Path::new("renamed.txt")), "report.txt").unwrap(),
            PathBuf::from("renamed.txt")
        );
    }

    #[test]
    fn content_types_and_sizes_are_friendly() {
        assert_eq!(
            content_type(Path::new("report.pdf"), None).unwrap(),
            "application/pdf"
        );
        assert_eq!(human_size("1536"), "1.5 KiB");
        assert_eq!(human_size("unknown"), "unknown");
    }
}