radkit-macros 0.0.2

Procedural macros for the radkit agent framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

/// Common MIME types that are valid for skills
pub const VALID_MIME_TYPES: &[&str] = &[
    // Wildcards
    "*/*",
    "text/*",
    "application/*",
    "image/*",
    "audio/*",
    "video/*",
    // Text types
    "text/plain",
    "text/html",
    "text/markdown",
    "text/csv",
    "text/xml",
    "text/css",
    "text/javascript",
    // Application types
    "application/json",
    "application/xml",
    "application/yaml",
    "application/x-yaml",
    "application/pdf",
    "application/zip",
    "application/octet-stream",
    "application/x-www-form-urlencoded",
    "application/javascript",
    // Image types
    "image/png",
    "image/jpeg",
    "image/jpg",
    "image/gif",
    "image/svg+xml",
    "image/webp",
    "image/bmp",
    // Audio types
    "audio/mpeg",
    "audio/wav",
    "audio/ogg",
    "audio/webm",
    // Video types
    "video/mp4",
    "video/mpeg",
    "video/webm",
    "video/ogg",
];

/// Validates a MIME type string
pub fn is_valid_mime_type(mime_type: &str) -> bool {
    VALID_MIME_TYPES.contains(&mime_type)
}

/// Suggests similar MIME types for a given invalid type
pub fn suggest_mime_type(invalid: &str) -> Vec<&'static str> {
    let invalid_lower = invalid.to_lowercase();

    VALID_MIME_TYPES
        .iter()
        .filter(|valid| {
            // Check if the valid type contains the invalid string or vice versa
            let valid_lower = valid.to_lowercase();
            valid_lower.contains(&invalid_lower) || invalid_lower.contains(&valid_lower)
        })
        .copied()
        .collect()
}

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

    #[test]
    fn test_valid_mime_types() {
        assert!(is_valid_mime_type("text/plain"));
        assert!(is_valid_mime_type("application/json"));
        assert!(is_valid_mime_type("image/png"));
        assert!(is_valid_mime_type("*/*"));
    }

    #[test]
    fn test_invalid_mime_types() {
        assert!(!is_valid_mime_type("text/invalid"));
        assert!(!is_valid_mime_type("invalid/type"));
    }

    #[test]
    fn test_suggestions() {
        let suggestions = suggest_mime_type("json");
        assert!(suggestions.contains(&"application/json"));

        let suggestions = suggest_mime_type("text/plai");
        assert!(suggestions.contains(&"text/plain"));
    }
}