#![allow(dead_code)]
use serde_json::Value;
use std::fs;
use std::path::Path;
use std::collections::HashMap;
fn detect_encoding(data: &[u8]) -> String {
if data.is_empty() {
return "text".to_string();
}
let limit = std::cmp::min(data.len(), 4096);
let sample = &data[..limit];
if sample.contains(&0) {
return "binary".to_string();
}
let mut non_text_count = 0;
for &b in sample {
if b < 9 || (b > 13 && b < 32) || b > 127 {
non_text_count += 1;
}
}
if non_text_count > (sample.len() * 30 / 100) {
"binary".to_string()
} else {
"text".to_string()
}
}
pub fn is_binary(data: &[u8]) -> bool {
detect_encoding(data) == "binary"
}
fn get_magic_rules(clm_root: &str) -> HashMap<String, String> {
let mut magic_rules = HashMap::new();
let types_dir = Path::new(clm_root).join("types");
if !types_dir.exists() {
return magic_rules;
}
let walk_dir = |dir: &Path, rules: &mut HashMap<String, String>| {
if let Ok(entries) = fs::read_dir(dir) {
for entry in entries.flatten() {
let path = entry.path();
if path.is_file()
&& let Some(ext) = path.extension().and_then(|s| s.to_str())
&& (ext == "yaml" || ext == "clm")
&& let Ok(content) = fs::read_to_string(&path)
&& let Ok(val) = serde_yaml::from_str::<Value>(&content) {
let inner = val.get("clm").unwrap_or(&val);
if let Some(concrete) = inner.get("concrete_impl").or_else(|| inner.get("concrete"))
&& let Some(content_type) = concrete.get("content_type") {
let mime = content_type.get("mime").and_then(|v| v.as_str()).unwrap_or_default();
let magic_bytes_str = content_type.get("detection_rules")
.and_then(|v| v.get("magic_bytes"))
.and_then(|v| v.as_str())
.unwrap_or_default();
if !mime.is_empty() && !magic_bytes_str.is_empty() {
rules.insert(magic_bytes_str.to_lowercase(), mime.to_string());
}
}
}
}
}
};
for folder in &["content", "transport", "meta"] {
walk_dir(&types_dir.join(folder), &mut magic_rules);
}
magic_rules
}
fn lookup_ext_hint(ext_hint: &str) -> Option<&'static str> {
if ext_hint.is_empty() {
return None;
}
let clean_hint = ext_hint.trim_start_matches('.').to_lowercase();
let ext_map = [
("md", crate::layer0::vocabulary_types::MIME_TEXT_MARKDOWN),
("py", crate::layer0::vocabulary_types::MIME_TEXT_X_PYTHON),
("sh", crate::layer0::vocabulary_types::MIME_TEXT_X_SHELLSCRIPT),
("js", crate::layer0::vocabulary_types::MIME_APPLICATION_JAVASCRIPT),
("yaml", crate::layer0::vocabulary_types::MIME_APPLICATION_YAML),
("yml", crate::layer0::vocabulary_types::MIME_APPLICATION_YAML),
("json", crate::layer0::vocabulary_types::MIME_APPLICATION_JSON),
("xml", crate::layer0::vocabulary_types::MIME_TEXT_XML),
("html", crate::layer0::vocabulary_types::MIME_TEXT_HTML),
("htm", crate::layer0::vocabulary_types::MIME_TEXT_HTML),
("svg", crate::layer0::vocabulary_types::MIME_IMAGE_SVG_XML),
("stl", crate::layer0::vocabulary_types::MIME_MODEL_STL),
("obj", crate::layer0::vocabulary_types::MIME_MODEL_OBJ),
("dxf", crate::layer0::vocabulary_types::MIME_IMAGE_VND_DXF),
("gltf", crate::layer0::vocabulary_types::MIME_MODEL_GLTF_JSON),
("tex", crate::layer0::vocabulary_types::MIME_TEXT_X_TEX),
("tikz", crate::layer0::vocabulary_types::MIME_TEXT_X_TIKZ),
("tikzcd", crate::layer0::vocabulary_types::MIME_TEXT_X_TIKZCD),
("tikz-cd", crate::layer0::vocabulary_types::MIME_TEXT_X_TIKZCD),
("djvu", crate::layer0::vocabulary_types::MIME_IMAGE_VND_DJVU),
("djv", crate::layer0::vocabulary_types::MIME_IMAGE_VND_DJVU),
("geojson", crate::layer0::vocabulary_types::MIME_APPLICATION_GEO_JSON),
("kml", crate::layer0::vocabulary_types::MIME_APPLICATION_VND_GOOGLE_EARTH_KML_XML),
("shp", crate::layer0::vocabulary_types::MIME_APPLICATION_X_SHAPEFILE),
("gpkg", crate::layer0::vocabulary_types::MIME_APPLICATION_GEOPACKAGE_SQLITE3),
("jpx", crate::layer0::vocabulary_types::MIME_IMAGE_JPX),
("jpf", crate::layer0::vocabulary_types::MIME_IMAGE_JPX),
];
for &(ext, mime) in &ext_map {
if clean_hint == ext {
return Some(mime);
}
}
None
}
pub fn detect_mime(data: &[u8], ext_hint: &str, clm_root: &str) -> String {
if data.is_empty() {
if let Some(mime) = lookup_ext_hint(ext_hint) {
return mime.to_string();
}
return crate::layer0::vocabulary_types::MIME_APPLICATION_OCTET_STREAM.to_string();
}
let limit = std::cmp::min(data.len(), 16);
let header_bytes = &data[..limit];
let hex_header = header_bytes.iter().map(|b| format!("{:02x}", b)).collect::<String>();
let mut magic_rules = get_magic_rules(clm_root);
let static_magic = [
("89504e470d0a1a0a", crate::layer0::vocabulary_types::MIME_IMAGE_PNG),
("ffd8ffe0", crate::layer0::vocabulary_types::MIME_IMAGE_JPEG),
("ffd8ffe1", crate::layer0::vocabulary_types::MIME_IMAGE_JPEG),
("ffd8ffe2", crate::layer0::vocabulary_types::MIME_IMAGE_JPEG),
("ffd8ffe3", crate::layer0::vocabulary_types::MIME_IMAGE_JPEG),
("ffd8ffe8", crate::layer0::vocabulary_types::MIME_IMAGE_JPEG),
("474946383761", crate::layer0::vocabulary_types::MIME_IMAGE_GIF),
("474946383961", crate::layer0::vocabulary_types::MIME_IMAGE_GIF),
("25504446", crate::layer0::vocabulary_types::MIME_APPLICATION_PDF),
("504b0304", crate::layer0::vocabulary_types::MIME_APPLICATION_ZIP),
("53514c69746520666f726d6174203300", crate::layer0::vocabulary_types::MIME_APPLICATION_SQLITE3),
("0000000c6a5020200d0a870a", crate::layer0::vocabulary_types::MIME_IMAGE_JPX),
];
for &(k, v) in &static_magic {
if !magic_rules.contains_key(k) {
magic_rules.insert(k.to_string(), v.to_string());
}
}
let mut sorted_rules: Vec<_> = magic_rules.into_iter().collect();
sorted_rules.sort_by_key(|a| std::cmp::Reverse(a.0.len()));
for (magic_hex, mime) in sorted_rules {
if hex_header.starts_with(&magic_hex) {
return mime;
}
}
if let Some(mime) = lookup_ext_hint(ext_hint) {
return mime.to_string();
}
if is_binary(data) {
crate::layer0::vocabulary_types::MIME_APPLICATION_OCTET_STREAM.to_string()
} else {
crate::layer0::vocabulary_types::MIME_TEXT_PLAIN.to_string()
}
}
fn hex_to_bytes(hex: &str) -> Option<Vec<u8>> {
let mut bytes = Vec::new();
let mut chars = hex.chars().peekable();
while let Some(c1) = chars.next() {
if let Some(&c2) = chars.peek() {
chars.next();
let byte_str = format!("{}{}", c1, c2);
if let Ok(b) = u8::from_str_radix(&byte_str, 16) {
bytes.push(b);
} else {
return None;
}
} else {
return None;
}
}
bytes.into()
}
pub fn validate(clm_root: &str, file_path: &str, mime: Option<&str>) -> bool {
let path = Path::new(file_path);
if !path.exists() || !path.is_file() {
return false;
}
let data = match fs::read(path) {
Ok(d) => d,
Err(_) => return false,
};
if data.is_empty() {
return false;
}
let resolved_mime = match mime {
Some(m) => m.to_string(),
None => {
let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("").to_lowercase();
detect_mime(&data, &ext, clm_root)
}
};
match resolved_mime.as_str() {
crate::layer0::vocabulary_types::MIME_APPLICATION_JSON => {
serde_json::from_slice::<Value>(&data).is_ok()
}
crate::layer0::vocabulary_types::MIME_APPLICATION_YAML | crate::layer0::vocabulary_types::MIME_APPLICATION_X_YAML => {
serde_yaml::from_slice::<Value>(&data).is_ok()
}
crate::layer0::vocabulary_types::MIME_TEXT_XML | crate::layer0::vocabulary_types::MIME_APPLICATION_XML | crate::layer0::vocabulary_types::MIME_IMAGE_SVG_XML => {
let mut reader = quick_xml::Reader::from_reader(&data[..]);
reader.check_end_names(true);
let mut buf = Vec::new();
loop {
match reader.read_event_into(&mut buf) {
Ok(quick_xml::events::Event::Eof) => break,
Err(_) => return false,
_ => {}
}
buf.clear();
}
true
}
m if m.starts_with("text/") => {
!is_binary(&data)
}
other_mime => {
let safe_mime = other_mime.chars().map(|c| if c.is_alphanumeric() { c } else { '_' }).collect::<String>();
let mut manifest_file = None;
for folder in &["content", "transport", "meta"] {
let candidate = Path::new(clm_root).join("types").join(folder).join(format!("{}.yaml", safe_mime));
if candidate.exists() {
manifest_file = Some(candidate);
break;
}
}
if let Some(m_file) = manifest_file
&& let Ok(content) = fs::read_to_string(m_file)
&& let Ok(val) = serde_yaml::from_str::<Value>(&content) {
let inner = val.get("clm").unwrap_or(&val);
let magic_bytes_str = inner.get("concrete_impl")
.and_then(|v| v.get("content_type"))
.and_then(|v| v.get("detection_rules"))
.and_then(|v| v.get("magic_bytes"))
.and_then(|v| v.as_str())
.unwrap_or_default();
if !magic_bytes_str.is_empty()
&& let Some(magic_bytes) = hex_to_bytes(magic_bytes_str) {
if data.len() >= magic_bytes.len() {
return data[..magic_bytes.len()] == magic_bytes[..];
} else {
return false;
}
}
}
true
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tikz_and_tikzcd_mime_detection() {
let dummy = b"\\begin{tikzcd}\nA \\arrow[r] & B\n\\end{tikzcd}";
assert_eq!(detect_mime(dummy, "tikz", ""), "text/x-tikz");
assert_eq!(detect_mime(dummy, "tikzcd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(dummy, "tikz-cd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(dummy, ".tikz-cd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(&[], "tikz-cd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(&[], "tikz", ""), "text/x-tikz");
assert_eq!(detect_mime(&[], "tikzcd", ""), "text/x-tikzcd");
}
}