use crate::args::CodecArg;
use embark_format::{CodecId, CryptoId, write_entry};
use proc_macro2::Span;
use quote::quote;
use std::path::{Path, PathBuf};
use syn::LitStr;
pub(crate) fn manifest_dir() -> PathBuf {
PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR is set by cargo"))
}
pub(crate) fn resolve(rel: &LitStr) -> PathBuf {
manifest_dir().join(rel.value())
}
fn read_error(err: &std::io::Error, shown: &str) -> String {
if err.kind() == std::io::ErrorKind::NotFound {
format!("embark: file not found: `{shown}` (resolved relative to CARGO_MANIFEST_DIR)")
} else {
format!("embark: cannot read `{shown}`: {err}")
}
}
pub(crate) fn at(span: Span) -> impl Fn(String) -> syn::Error {
move |message| syn::Error::new(span, message)
}
pub(crate) fn read(path: &Path, shown: &str) -> Result<Vec<u8>, String> {
std::fs::read(path).map_err(|e| read_error(&e, shown))
}
pub(crate) fn ensure_readable(path: &Path, shown: &str, span: Span) -> syn::Result<()> {
std::fs::File::open(path)
.map(drop)
.map_err(|e| syn::Error::new(span, read_error(&e, shown)))
}
pub(crate) fn path_str(path: &Path, span: Span) -> syn::Result<&str> {
path.to_str().ok_or_else(|| {
syn::Error::new(
span,
format!("embark: path is not valid UTF-8: {}", path.display()),
)
})
}
pub(crate) fn track_file(path: &Path, span: Span) -> syn::Result<proc_macro2::TokenStream> {
let abs = path_str(path, span)?;
Ok(quote!(
const _: &[::core::primitive::u8] = ::core::include_bytes!(#abs);
))
}
fn codec_name(codec: CodecId) -> String {
match codec {
CodecId::Store => "store".to_string(),
CodecId::Deflate => "deflate".to_string(),
CodecId::Lz4 => "lz4".to_string(),
CodecId::Snappy => "snappy".to_string(),
CodecId::Zstd => "zstd".to_string(),
CodecId::Lzma => "lzma".to_string(),
other => format!("codec id {}", other.as_u8()),
}
}
fn verify_decode(codec: CodecId, data: &[u8], payload: &[u8], shown: &str) -> Result<(), String> {
let fail = |detail: &str| {
let name = codec_name(codec);
format!(
"embark: `{shown}`: the {name} encoder produced a payload this build's \
decoder cannot read back ({detail}). This is a bug in embark, not in \
the asset; please report it."
)
};
let decoded = embark_codec::decompress(codec, payload, data.len())
.map_err(|e| fail(&format!("decoding failed: {e}")))?;
if decoded.len() != data.len() {
return Err(fail(&format!(
"decoded to {} bytes, expected {}",
decoded.len(),
data.len()
)));
}
if let Some(at) = decoded.iter().zip(data).position(|(a, b)| a != b) {
return Err(fail(&format!(
"decoded output first differs at byte {at}: expected {:#04x}, got {:#04x}",
data[at], decoded[at]
)));
}
Ok(())
}
pub(crate) fn compress_verified(
codec: CodecArg,
data: &[u8],
shown: &str,
) -> Result<(CodecId, Vec<u8>), String> {
let (codec, payload) = match codec {
CodecArg::Auto(tier) => embark_codec::compress_best_in(tier, data),
CodecArg::Fixed(id) => {
let payload = embark_codec::compress(id, data);
if payload.len() < data.len() {
(id, payload)
} else {
(CodecId::Store, data.to_vec())
}
}
};
verify_decode(codec, data, &payload, shown)?;
Ok((codec, payload))
}
pub(crate) fn build_entry(codec: CodecArg, data: &[u8], shown: &str) -> Result<Vec<u8>, String> {
let (codec, payload) = compress_verified(codec, data, shown)?;
let mut entry = Vec::new();
write_entry(
&mut entry,
codec,
CryptoId::None,
data.len() as u64,
None,
&payload,
);
Ok(entry)
}
pub(crate) fn bytes_literal(bytes: &[u8]) -> proc_macro2::Literal {
proc_macro2::Literal::byte_string(bytes)
}
#[cfg(test)]
mod tests {
use super::*;
const DATA: &[u8] = b"embark verifies that the decoder can read the encoder";
#[test]
fn a_corrupted_payload_names_the_path_the_codec_and_the_offset() {
let mut payload = DATA.to_vec();
payload[12] ^= 0x01;
let msg = verify_decode(CodecId::Store, DATA, &payload, "assets/logo.png")
.expect_err("a flipped byte must not verify");
assert!(msg.contains("assets/logo.png"), "{msg}");
assert!(msg.contains("store"), "{msg}");
assert!(msg.contains("byte 12"), "{msg}");
}
#[test]
fn a_truncated_payload_is_reported_as_a_decoder_rejection() {
let msg = verify_decode(
CodecId::Store,
DATA,
&DATA[..DATA.len() - 1],
"assets/logo.png",
)
.expect_err("a truncated payload must not verify");
assert!(msg.contains("assets/logo.png"), "{msg}");
assert!(msg.contains("decoding failed"), "{msg}");
}
#[test]
fn an_untouched_payload_verifies() {
let (codec, payload) =
compress_verified(CodecArg::Fixed(CodecId::Store), DATA, "assets/logo.png")
.expect("store must round-trip");
assert_eq!(codec, CodecId::Store);
assert_eq!(payload, DATA);
}
}