monolith/src/utils.rs

158 lines
4.5 KiB
Rust
Raw Normal View History

2019-08-23 05:17:15 +02:00
extern crate base64;
use self::base64::encode;
use http::retrieve_asset;
2019-10-12 13:05:07 +02:00
use regex::Regex;
2019-12-06 02:20:09 +01:00
use std::collections::HashMap;
2019-12-06 02:41:43 +01:00
use url::{ParseError, Url};
2019-09-29 23:15:49 +02:00
lazy_static! {
static ref HAS_PROTOCOL: Regex = Regex::new(r"^[a-z0-9]+:").unwrap();
static ref REGEX_URL: Regex = Regex::new(r"^https?://").unwrap();
}
2019-08-24 00:48:08 +02:00
2019-10-10 15:23:00 +02:00
const MAGIC: [[&[u8]; 2]; 19] = [
2019-08-24 00:48:08 +02:00
// Image
[b"GIF87a", b"image/gif"],
[b"GIF89a", b"image/gif"],
[b"\xFF\xD8\xFF", b"image/jpeg"],
[b"\x89PNG\x0D\x0A\x1A\x0A", b"image/png"],
[b"<?xml ", b"image/svg+xml"],
[b"<svg ", b"image/svg+xml"],
[b"RIFF....WEBPVP8 ", b"image/webp"],
[b"\x00\x00\x01\x00", b"image/x-icon"],
// Audio
[b"ID3", b"audio/mpeg"],
[b"\xFF\x0E", b"audio/mpeg"],
[b"\xFF\x0F", b"audio/mpeg"],
[b"OggS", b"audio/ogg"],
[b"RIFF....WAVEfmt ", b"audio/wav"],
[b"fLaC", b"audio/x-flac"],
// Video
[b"RIFF....AVI LIST", b"video/avi"],
[b"....ftyp", b"video/mp4"],
[b"\x00\x00\x01\x0B", b"video/mpeg"],
[b"....moov", b"video/quicktime"],
[b"\x1A\x45\xDF\xA3", b"video/webm"],
];
2019-08-23 05:17:15 +02:00
pub fn data_to_dataurl(mime: &str, data: &[u8]) -> String {
2019-10-10 15:23:00 +02:00
let mimetype = if mime.is_empty() {
2019-08-23 20:24:45 +02:00
detect_mimetype(data)
2019-08-23 05:17:15 +02:00
} else {
2019-08-23 20:24:45 +02:00
mime.to_string()
};
2019-08-23 05:17:15 +02:00
format!("data:{};base64,{}", mimetype, encode(data))
}
2019-09-29 23:15:49 +02:00
pub fn detect_mimetype(data: &[u8]) -> String {
for item in MAGIC.iter() {
2019-08-24 00:48:08 +02:00
if data.starts_with(item[0]) {
2019-10-10 15:23:00 +02:00
return String::from_utf8(item[1].to_vec()).unwrap();
2019-08-24 00:48:08 +02:00
}
}
2019-10-10 15:23:00 +02:00
"".to_owned()
2019-08-23 05:17:15 +02:00
}
2019-10-10 15:23:00 +02:00
pub fn url_has_protocol<T: AsRef<str>>(url: T) -> bool {
HAS_PROTOCOL.is_match(url.as_ref().to_lowercase().as_str())
2019-09-29 23:15:49 +02:00
}
2019-08-23 05:17:15 +02:00
2019-10-10 15:23:00 +02:00
pub fn is_data_url<T: AsRef<str>>(url: T) -> Result<bool, ParseError> {
Url::parse(url.as_ref()).and_then(|u| Ok(u.scheme() == "data"))
2019-09-29 23:15:49 +02:00
}
2019-08-24 00:48:08 +02:00
2019-10-10 15:23:00 +02:00
pub fn is_valid_url<T: AsRef<str>>(path: T) -> bool {
REGEX_URL.is_match(path.as_ref())
2019-09-29 23:15:49 +02:00
}
2019-10-10 15:23:00 +02:00
pub fn resolve_url<T: AsRef<str>, U: AsRef<str>>(from: T, to: U) -> Result<String, ParseError> {
let result = if is_valid_url(to.as_ref()) {
to.as_ref().to_string()
2019-09-29 23:15:49 +02:00
} else {
2019-10-10 15:23:00 +02:00
Url::parse(from.as_ref())?
.join(to.as_ref())?
.as_ref()
.to_string()
2019-09-29 23:15:49 +02:00
};
Ok(result)
2019-08-23 05:17:15 +02:00
}
2019-10-12 13:05:07 +02:00
pub fn resolve_css_imports(
2019-12-06 01:01:03 +01:00
cache: &mut HashMap<String, String>,
2019-10-12 13:05:07 +02:00
css_string: &str,
2019-12-06 02:05:52 +01:00
as_dataurl: bool,
2019-10-12 13:05:07 +02:00
href: &str,
opt_user_agent: &str,
opt_silent: bool,
opt_insecure: bool,
) -> String {
let mut resolved_css = String::from(css_string);
2019-12-06 02:41:43 +01:00
let re =
Regex::new(r###"(?P<import>@import )?url\((?P<to_repl>"?(?P<url>[^"]+)"?)\)"###).unwrap();
2019-10-12 13:05:07 +02:00
for link in re.captures_iter(&css_string) {
let target_link = link.name("url").unwrap().as_str();
// Generate absolute URL for content
let embedded_url = match resolve_url(href, target_link) {
Ok(url) => url,
Err(_) => continue, // Malformed URL
2019-10-12 13:05:07 +02:00
};
// Download the asset. If it's more CSS, resolve that too
let content = match link.name("import") {
// The link is an @import link
Some(_) => retrieve_asset(
2019-12-06 02:41:43 +01:00
cache,
&embedded_url,
false, // Formating as data URL will be done later
"text/css", // Expect CSS
opt_user_agent,
opt_silent,
opt_insecure,
)
.map(|(content, _)| {
resolve_css_imports(
cache,
&content,
true, //NOW, convert to data URL
&embedded_url,
opt_user_agent,
opt_silent,
opt_insecure,
)
}),
// The link is some other, non-@import link
None => retrieve_asset(
2019-12-06 02:41:43 +01:00
cache,
&embedded_url,
true, // Format as data URL
"", // Unknown MIME type
opt_user_agent,
opt_silent,
opt_insecure,
)
.map(|(a, _)| a),
}
.unwrap_or_else(|e| {
eprintln!("Warning: {}", e,);
//If failed to resolve, replace with absolute URL
embedded_url
});
let replacement = format!("\"{}\"", &content);
let dest = link.name("to_repl").unwrap();
resolved_css.replace_range(dest.start()..dest.end(), &replacement);
}
2019-12-06 02:05:52 +01:00
if as_dataurl {
data_to_dataurl("text/css", resolved_css.as_bytes())
} else {
resolved_css
}
2019-10-12 13:05:07 +02:00
}