use alloc::borrow::Cow;
use embark_format::Result;
#[non_exhaustive]
pub struct Manifest {
pub path: &'static str,
pub entry: &'static [u8],
}
impl core::fmt::Debug for Manifest {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Manifest")
.field("path", &self.path)
.field("entry_len", &self.entry.len())
.finish()
}
}
impl Manifest {
#[must_use]
pub const fn new(path: &'static str, entry: &'static [u8]) -> Manifest {
Manifest { path, entry }
}
}
pub trait Embed {
fn get(path: &str) -> Option<EmbeddedFile>;
fn iter() -> Entries;
}
enum Source {
Static(&'static [u8]),
#[cfg(feature = "std")]
Owned(alloc::vec::Vec<u8>),
}
pub struct EmbeddedFile {
source: Source,
path: Cow<'static, str>,
#[cfg(feature = "encryption")]
recon: Option<fn() -> [u8; 32]>,
}
impl core::fmt::Debug for EmbeddedFile {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("EmbeddedFile")
.field("path", &self.path())
.field("size", &self.size())
.finish_non_exhaustive()
}
}
impl EmbeddedFile {
#[must_use]
pub fn data(&self) -> Cow<'static, [u8]> {
self.try_data()
.expect("embark: embedded entry is malformed (build-time bug)")
}
pub fn try_data(&self) -> Result<Cow<'static, [u8]>> {
match &self.source {
#[cfg(feature = "encryption")]
Source::Static(entry) => {
let key = self
.recon
.map(|recon| embark_crypt::Zeroizing::new(recon()));
crate::decode::decode(entry, key.as_deref())
}
#[cfg(not(feature = "encryption"))]
Source::Static(entry) => crate::decode::decode(entry, None),
#[cfg(feature = "std")]
Source::Owned(bytes) => Ok(Cow::Owned(bytes.clone())),
}
}
#[must_use]
pub fn size(&self) -> Option<usize> {
match &self.source {
Source::Static(entry) => {
let header = embark_format::read_header(entry).ok()?;
usize::try_from(header.orig_len).ok()
}
#[cfg(feature = "std")]
Source::Owned(bytes) => Some(bytes.len()),
}
}
#[must_use]
pub fn path(&self) -> &str {
&self.path
}
}
pub struct Entries {
inner: core::slice::Iter<'static, Manifest>,
}
impl core::fmt::Debug for Entries {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Entries")
.field("remaining", &self.inner.len())
.finish()
}
}
impl Iterator for Entries {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|m| m.path)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
impl DoubleEndedIterator for Entries {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back().map(|m| m.path)
}
}
impl ExactSizeIterator for Entries {
fn len(&self) -> usize {
self.inner.len()
}
}
impl core::iter::FusedIterator for Entries {}
#[must_use]
pub fn lookup(manifest: &'static [Manifest], path: &str) -> Option<EmbeddedFile> {
let idx = manifest.binary_search_by(|m| m.path.cmp(path)).ok()?;
let m = &manifest[idx];
Some(EmbeddedFile {
source: Source::Static(m.entry),
path: Cow::Borrowed(m.path),
#[cfg(feature = "encryption")]
recon: None,
})
}
#[must_use]
pub fn entries(manifest: &'static [Manifest]) -> Entries {
Entries {
inner: manifest.iter(),
}
}
#[cfg(feature = "encryption")]
pub fn lookup_encrypted(
manifest: &'static [Manifest],
path: &str,
recon: fn() -> [u8; 32],
) -> Option<EmbeddedFile> {
let idx = manifest.binary_search_by(|m| m.path.cmp(path)).ok()?;
let m = &manifest[idx];
Some(EmbeddedFile {
source: Source::Static(m.entry),
path: Cow::Borrowed(m.path),
recon: Some(recon),
})
}
#[cfg(feature = "std")]
#[doc(hidden)]
#[must_use]
pub fn __dev_file(
manifest: &'static [Manifest],
folder_abs: &str,
path: &str,
) -> Option<EmbeddedFile> {
use std::path::Path;
lookup(manifest, path)?;
let folder = Path::new(folder_abs);
let real = std::fs::canonicalize(folder.join(path)).ok()?;
let root = std::fs::canonicalize(folder).ok()?;
if !real.starts_with(&root) {
return None;
}
let bytes = std::fs::read(&real).ok()?;
Some(EmbeddedFile {
source: Source::Owned(bytes),
path: Cow::Owned(path.to_string()),
#[cfg(feature = "encryption")]
recon: None,
})
}