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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
#[cfg(feature = "phf")]
extern crate phf_codegen;
extern crate unicase;
use unicase::UniCase;
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufWriter;
use std::path::Path;
use std::collections::BTreeMap;
use mime_types::MIME_TYPES;
#[path = "src/mime_types.rs"]
mod mime_types;
#[cfg(feature = "phf")]
const PHF_PATH: &str = "::impl_::phf";
fn main() {
let out_dir = env::var("OUT_DIR").unwrap();
let dest_path = Path::new(&out_dir).join("mime_types_generated.rs");
let mut outfile = BufWriter::new(File::create(dest_path).unwrap());
#[cfg(feature = "phf")]
build_forward_map(&mut outfile);
#[cfg(feature = "rev-mappings")]
build_rev_map(&mut outfile);
}
// Build forward mappings (ext -> mime type)
#[cfg(feature = "phf")]
fn build_forward_map<W: Write>(out: &mut W) {
use phf_codegen::Map as PhfMap;
let mut forward_map = PhfMap::new();
forward_map.phf_path(PHF_PATH);
let mut map_entries: Vec<(&str, Vec<&str>)> = Vec::new();
for &(key, types) in MIME_TYPES {
if let Some(&mut (key_, ref mut values)) = map_entries.last_mut() {
// deduplicate extensions
if key == key_ {
values.extend_from_slice(types);
continue;
}
}
map_entries.push((key, types.into()));
}
for (key, values) in map_entries {
forward_map.entry(
UniCase::new(key),
&format!("&{:?}", values),
);
}
writeln!(
out,
"static MIME_TYPES: phf::Map<UniCase<&'static str>, &'static [&'static str]> = \n{};",
forward_map.build()
)
.unwrap();
}
// Build reverse mappings (mime type -> ext)
#[cfg(all(feature = "phf", feature = "rev-mappings"))]
fn build_rev_map<W: Write>(out: &mut W) {
use phf_codegen::Map as PhfMap;
let dyn_map = get_rev_mappings();
let mut rev_map = PhfMap::new();
rev_map.phf_path(PHF_PATH);
let mut exts = Vec::new();
for (top, subs) in dyn_map {
let top_start = exts.len();
let mut sub_map = PhfMap::new();
sub_map.phf_path(PHF_PATH);
for (sub, sub_exts) in subs {
let sub_start = exts.len();
exts.extend(sub_exts);
let sub_end = exts.len();
sub_map.entry(sub, &format!("({}, {})", sub_start, sub_end));
}
let top_end = exts.len();
rev_map.entry(
top,
&format!(
"TopLevelExts {{ start: {}, end: {}, subs: {} }}",
top_start, top_end, sub_map.build()
),
);
}
writeln!(
out,
"static REV_MAPPINGS: phf::Map<UniCase<&'static str>, TopLevelExts> = \n{};",
rev_map.build()
).unwrap();
writeln!(out, "const EXTS: &'static [&'static str] = &{:?};", exts).unwrap();
}
#[cfg(all(not(feature = "phf"), feature = "rev-mappings"))]
fn build_rev_map<W: Write>(out: &mut W) {
use std::fmt::Write as _;
macro_rules! unicase_const {
($s:expr) => ({
format_args!("{}({:?})", (if $s.is_ascii() {
"UniCase::ascii"
} else {
"UniCase::unicode"
}), $s)
})
}
let dyn_map = get_rev_mappings();
write!(out, "static REV_MAPPINGS: &'static [(UniCase<&'static str>, TopLevelExts)] = &[").unwrap();
let mut exts = Vec::new();
for (top, subs) in dyn_map {
let top_start = exts.len();
let mut sub_map = String::new();
for (sub, sub_exts) in subs {
let sub_start = exts.len();
exts.extend(sub_exts);
let sub_end = exts.len();
write!(
sub_map,
"({}, ({}, {})),",
unicase_const!(sub), sub_start, sub_end
).unwrap();
}
let top_end = exts.len();
write!(
out,
"({}, TopLevelExts {{ start: {}, end: {}, subs: &[{}] }}),",
unicase_const!(top), top_start, top_end, sub_map
).unwrap();
}
writeln!(out, "];").unwrap();
writeln!(out, "const EXTS: &'static [&'static str] = &{:?};", exts).unwrap();
}
#[cfg(feature = "rev-mappings")]
fn get_rev_mappings(
) -> BTreeMap<UniCase<&'static str>, BTreeMap<UniCase<&'static str>, Vec<&'static str>>> {
// First, collect all the mime type -> ext mappings)
let mut dyn_map = BTreeMap::new();
for &(key, types) in MIME_TYPES {
for val in types {
let (top, sub) = split_mime(val);
dyn_map
.entry(UniCase::new(top))
.or_insert_with(BTreeMap::new)
.entry(UniCase::new(sub))
.or_insert_with(Vec::new)
.push(key);
}
}
dyn_map
}
fn split_mime(mime: &str) -> (&str, &str) {
let split_idx = mime.find('/').unwrap();
(&mime[..split_idx], &mime[split_idx + 1..])
}
|
