robinpath_modules/modules/

mime_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("mime.lookup", |args, _| {
        let ext = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let ext = ext.trim_start_matches('.').to_lowercase();
        Ok(Value::String(
            ext_to_mime(&ext).unwrap_or("application/octet-stream").to_string(),
        ))
    });

    rp.register_builtin("mime.extension", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(match mime_to_ext(&mime) {
            Some(ext) => Value::String(ext.to_string()),
            None => Value::Null,
        })
    });

    rp.register_builtin("mime.isText", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(
            mime.starts_with("text/")
                || mime.contains("json")
                || mime.contains("xml")
                || mime.contains("javascript")
                || mime.contains("yaml"),
        ))
    });

    rp.register_builtin("mime.isImage", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(mime.starts_with("image/")))
    });

    rp.register_builtin("mime.isAudio", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(mime.starts_with("audio/")))
    });

    rp.register_builtin("mime.isVideo", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(mime.starts_with("video/")))
    });

    rp.register_builtin("mime.isFont", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(mime.starts_with("font/") || mime.contains("font")))
    });

    rp.register_builtin("mime.isArchive", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let archive_types = [
            "application/zip",
            "application/gzip",
            "application/x-tar",
            "application/x-rar-compressed",
            "application/x-7z-compressed",
            "application/x-bzip2",
        ];
        Ok(Value::Bool(archive_types.contains(&mime.as_str())))
    });

    rp.register_builtin("mime.charset", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        if mime.starts_with("text/") || mime.contains("json") || mime.contains("xml") || mime.contains("javascript") {
            Ok(Value::String("UTF-8".to_string()))
        } else {
            Ok(Value::Null)
        }
    });

    rp.register_builtin("mime.contentType", |args, _| {
        let mime = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        if mime.starts_with("text/") || mime.contains("json") || mime.contains("xml") || mime.contains("javascript") {
            Ok(Value::String(format!("{}; charset=utf-8", mime)))
        } else {
            Ok(Value::String(mime))
        }
    });

    rp.register_builtin("mime.detect", |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        // Detect by file extension from path
        if let Some(ext) = std::path::Path::new(&path).extension() {
            let ext_str = ext.to_string_lossy().to_lowercase();
            Ok(Value::String(
                ext_to_mime(&ext_str).unwrap_or("application/octet-stream").to_string(),
            ))
        } else {
            Ok(Value::String("application/octet-stream".to_string()))
        }
    });

    rp.register_builtin("mime.allTypes", |_args, _| {
        let mut obj = indexmap::IndexMap::new();
        for (ext, mime) in MIME_TABLE {
            obj.insert(ext.to_string(), Value::String(mime.to_string()));
        }
        Ok(Value::Object(obj))
    });
}

const MIME_TABLE: &[(&str, &str)] = &[
    ("html", "text/html"),
    ("htm", "text/html"),
    ("css", "text/css"),
    ("js", "application/javascript"),
    ("mjs", "application/javascript"),
    ("json", "application/json"),
    ("xml", "application/xml"),
    ("txt", "text/plain"),
    ("csv", "text/csv"),
    ("md", "text/markdown"),
    ("yaml", "application/x-yaml"),
    ("yml", "application/x-yaml"),
    ("toml", "application/toml"),
    ("png", "image/png"),
    ("jpg", "image/jpeg"),
    ("jpeg", "image/jpeg"),
    ("gif", "image/gif"),
    ("svg", "image/svg+xml"),
    ("webp", "image/webp"),
    ("ico", "image/x-icon"),
    ("bmp", "image/bmp"),
    ("tiff", "image/tiff"),
    ("avif", "image/avif"),
    ("mp3", "audio/mpeg"),
    ("wav", "audio/wav"),
    ("ogg", "audio/ogg"),
    ("flac", "audio/flac"),
    ("aac", "audio/aac"),
    ("mp4", "video/mp4"),
    ("webm", "video/webm"),
    ("avi", "video/x-msvideo"),
    ("mkv", "video/x-matroska"),
    ("mov", "video/quicktime"),
    ("pdf", "application/pdf"),
    ("zip", "application/zip"),
    ("gz", "application/gzip"),
    ("tar", "application/x-tar"),
    ("rar", "application/x-rar-compressed"),
    ("7z", "application/x-7z-compressed"),
    ("woff", "font/woff"),
    ("woff2", "font/woff2"),
    ("ttf", "font/ttf"),
    ("otf", "font/otf"),
    ("eot", "application/vnd.ms-fontobject"),
    ("wasm", "application/wasm"),
    ("doc", "application/msword"),
    ("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
    ("xls", "application/vnd.ms-excel"),
    ("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
    ("ppt", "application/vnd.ms-powerpoint"),
    ("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"),
    ("ts", "application/typescript"),
    ("tsx", "application/typescript"),
    ("jsx", "application/javascript"),
    ("rs", "text/x-rust"),
    ("go", "text/x-go"),
    ("py", "text/x-python"),
    ("rb", "text/x-ruby"),
    ("java", "text/x-java"),
    ("c", "text/x-c"),
    ("cpp", "text/x-c++"),
    ("h", "text/x-c"),
    ("sh", "application/x-sh"),
    ("bat", "application/x-msdos-program"),
    ("sql", "application/sql"),
];

fn ext_to_mime(ext: &str) -> Option<&'static str> {
    MIME_TABLE.iter().find(|(e, _)| *e == ext).map(|(_, m)| *m)
}

fn mime_to_ext(mime: &str) -> Option<&'static str> {
    MIME_TABLE.iter().find(|(_, m)| *m == mime).map(|(e, _)| *e)
}