material-code-icons 0.1.0

VS Code Material Icon Theme in Rust
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#![allow(unused)]

use glob::glob;
use std::{collections::HashMap, fmt::format};

fn main() {
    let mut icon_idxs = HashMap::new();
    let mut bare_icons = String::new();
    let mut icon_arr = String::new();
    let mut names = String::new();
    let mut icon_count: usize = 0;
    let mut names_count: usize = 0;

    for entry in glob("./vscode-material-icon-theme/icons/*.svg")
        .expect("Failed to read glob patter")
        .filter_map(|r| r.ok())
        .filter(|entry| entry.is_file())
    {
        let name = entry.file_stem().unwrap().to_str().unwrap();
        eprintln!("{name}");
        let id = name.replace('-', "_").replace('3', "THREE_").to_uppercase();

        icon_idxs.insert(name.to_owned(), icon_count);
        bare_icons.push_str(format!("pub const {id}: &'static [u8] = include_bytes!(\"../vscode-material-icon-theme/icons/{name}.svg\");\n").as_str());
        icon_arr.push_str(format!("\t{id},\n").as_str());

        icon_count += 1;
    }

    let file_icons_json = include_str!("src/file_icons.json");
    let folder_icons_json = include_str!("src/folder_icons.json");
    let language_icons_json = include_str!("src/language_icons.json");

    let file_icons_values: serde_json::Value =
        serde_json::from_str(file_icons_json).expect("Could not deserialze file_icons.json");
    let folder_icons_values: serde_json::Value =
        serde_json::from_str(folder_icons_json).expect("Could not deserialze folder_icons.json");
    let language_icons_values: serde_json::Value = serde_json::from_str(language_icons_json)
        .expect("Could not deserialze language_icons.json");

    for lang in language_icons_values
        .as_array()
        .unwrap()
        .iter()
        .map(|val| val.as_object().unwrap())
    {
        let name = lang
            .get("icon")
            .unwrap()
            .get("name")
            .unwrap()
            .as_str()
            .unwrap();

        let idx = icon_idxs
            .get(name)
            .expect(format!("No icon found for {name}").as_str());

        names.push_str(format!("\t(\"{name}\",{idx}),\n").as_str());
        names_count += 1;
    }

    // TODO: Use default icon
    for file_id in file_icons_values
        .get("icons")
        .unwrap()
        .as_array()
        .unwrap()
        .iter()
        .map(|val| val.as_object().unwrap())
    {
        let name = file_id.get("name").unwrap().as_str().unwrap();
        let idx = icon_idxs
            .get(name)
            .expect(format!("No icon found for {name}").as_str());

        for id in ["fileNames", "fileExtensions"]
            .iter()
            .filter_map(|id| file_id.get(*id))
            .map(|val| val.as_array().unwrap().iter())
            .flatten()
            .map(|val| val.as_str().unwrap())
        {
            names.push_str(format!("\t(\"{id}\",{idx}),\n").as_str());
            names_count += 1;
        }
    }

    for folder_id in folder_icons_values.as_array().unwrap()[0]
        .get("icons")
        .unwrap()
        .as_array()
        .unwrap()
        .iter()
        .map(|val| val.as_object().unwrap())
    {
        let name = folder_id.get("name").unwrap().as_str().unwrap();
        let idx = icon_idxs
            .get(name)
            .expect(format!("No icon found for {name}").as_str());

        for folder_name in folder_id
            .get("folderNames")
            .unwrap()
            .as_array()
            .unwrap()
            .iter()
            .map(|val| val.as_str().unwrap())
        {
            names.push_str(format!("\t(\"{folder_name}\",{idx}),\n").as_str());
            names_count += 1;
        }
    }

    let contents = format!(
        "
{bare_icons}
pub(crate) const ICONS: [&[u8]; {icon_count}] = [
{icon_arr}
];
		
pub(crate) const NAMES: [(&str, usize); {names_count}] = [
{names}
];
"
    );
    std::fs::write("target/icons.rs", contents).expect("Could not write icons.rs to disk");
}