use crate::error::PackageError;
use crate::package::Package;
use crate::parse::parse_package_content;
use crate::paths;
use std::collections::BTreeMap;
use std::fs;
use std::path::Path;
pub fn load_dir(dir: &Path) -> Result<Package, PackageError> {
validate_assets_tree(dir)?;
validate_content_tree(dir)?;
let manifest_raw = fs::read_to_string(dir.join(paths::MANIFEST))?;
let root_raw = fs::read_to_string(dir.join(paths::ROOT))?;
let theme_json = fs::read_to_string(dir.join(paths::THEME))?;
let content_files = read_content_json_files(dir)?;
let parsed = parse_package_content(&manifest_raw, &root_raw, &theme_json, &content_files)?;
let fonts = read_dir_files(
dir.join(paths::FONTS_DIR.trim_end_matches('/')),
paths::FONTS_DIR,
)?;
let mut assets = read_dir_files(
dir.join(paths::IMAGES_DIR.trim_end_matches('/')),
paths::IMAGES_DIR,
)?;
assets.extend(read_dir_files(
dir.join(paths::DATA_DIR.trim_end_matches('/')),
paths::DATA_DIR,
)?);
let mut schemas = BTreeMap::new();
for (path, text) in crate::schema::bundled_schema_files() {
schemas.insert(path.to_string(), text.to_string());
}
let changelog_json = match fs::read_to_string(dir.join(paths::CHANGELOG)) {
Ok(s) => s,
Err(_) => paths::EMPTY_CHANGELOG.to_string(),
};
let tokens_json = fs::read_to_string(dir.join(paths::TOKENS)).ok();
let lock_json = fs::read_to_string(dir.join(paths::LOCK)).ok();
let signatures_json = fs::read_to_string(dir.join(paths::SIGNATURES)).ok();
let mut pkg = Package {
manifest: parsed.manifest,
root: parsed.root,
include_map: parsed.include_map,
theme_json,
fonts,
assets,
schemas,
changelog_json,
tokens_json,
lock_json,
signatures_json,
};
pkg.finalize()?;
Ok(pkg)
}
fn read_content_json_files(dir: &Path) -> Result<BTreeMap<String, String>, PackageError> {
let content_dir = dir.join("content");
let mut out = BTreeMap::new();
if !content_dir.exists() {
return Ok(out);
}
read_content_json_rec(dir, &content_dir, &mut out)?;
Ok(out)
}
fn read_content_json_rec(
package_dir: &Path,
dir: &Path,
out: &mut BTreeMap<String, String>,
) -> Result<(), PackageError> {
for entry in fs::read_dir(dir)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
read_content_json_rec(package_dir, &path, out)?;
} else if path.is_file() {
let rel = path
.strip_prefix(package_dir)
.map_err(|e| PackageError::Other(e.to_string()))?
.to_string_lossy()
.replace('\\', "/");
if !rel.ends_with(".json") {
return Err(PackageError::UnexpectedPath(format!(
"{rel} (only .json files are allowed under content/)"
)));
}
if !paths::is_content_json_path(&rel) && rel != paths::ROOT {
return Err(PackageError::UnexpectedPath(format!("{rel}")));
}
out.insert(rel, fs::read_to_string(&path)?);
}
}
Ok(())
}
pub fn validate_content_tree(package_dir: &Path) -> Result<(), PackageError> {
let content_dir = package_dir.join("content");
if !content_dir.exists() {
return Ok(());
}
validate_content_entries(package_dir, &content_dir)
}
fn validate_content_entries(package_dir: &Path, dir: &Path) -> Result<(), PackageError> {
for entry in fs::read_dir(dir)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
validate_content_entries(package_dir, &path)?;
} else if path.is_file() {
let rel = path
.strip_prefix(package_dir)
.map_err(|e| PackageError::Other(e.to_string()))?
.to_string_lossy()
.replace('\\', "/");
if !rel.ends_with(".json") {
return Err(PackageError::UnexpectedPath(format!(
"{rel} (only .json files are allowed under content/)"
)));
}
}
}
Ok(())
}
fn read_dir_files(
dir: impl AsRef<Path>,
prefix: &str,
) -> Result<BTreeMap<String, Vec<u8>>, PackageError> {
let dir = dir.as_ref();
let mut out = BTreeMap::new();
if !dir.exists() {
return Ok(out);
}
read_dir_files_rec(dir, dir, prefix, &mut out)?;
Ok(out)
}
fn read_dir_files_rec(
root: &Path,
dir: &Path,
prefix: &str,
out: &mut BTreeMap<String, Vec<u8>>,
) -> Result<(), PackageError> {
for entry in fs::read_dir(dir)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
read_dir_files_rec(root, &path, prefix, out)?;
} else if path.is_file() {
let rel = path
.strip_prefix(root)
.map_err(|e| PackageError::Other(e.to_string()))?
.to_string_lossy()
.replace('\\', "/");
out.insert(format!("{prefix}{rel}"), fs::read(&path)?);
}
}
Ok(())
}
pub fn validate_assets_tree(package_dir: &Path) -> Result<(), PackageError> {
let assets_dir = package_dir.join("assets");
if !assets_dir.exists() {
return Ok(());
}
validate_assets_entries(&assets_dir, &assets_dir)
}
fn validate_assets_entries(assets_root: &Path, dir: &Path) -> Result<(), PackageError> {
for entry in fs::read_dir(dir)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
if dir == assets_root {
let name = path
.file_name()
.and_then(|n| n.to_str())
.unwrap_or_default();
if name != "fonts" && name != "images" && name != "data" {
return Err(PackageError::UnexpectedPath(format!(
"assets/{name}/ (only fonts/, images/, and data/ are allowed)"
)));
}
}
validate_assets_entries(assets_root, &path)?;
} else if path.is_file() && dir == assets_root {
let name = path
.file_name()
.and_then(|n| n.to_str())
.unwrap_or_default();
return Err(PackageError::UnexpectedPath(format!(
"assets/{name} (place files under assets/fonts/, assets/images/, or assets/data/)"
)));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::CODE_UNEXPECTED_PATH;
use std::fs;
#[test]
fn rejects_assets_outside_allowed_subdirs() {
let base = std::env::temp_dir().join(format!(
"k2f_pack_assets_test_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&base);
fs::create_dir_all(base.join("assets/fonts")).unwrap();
fs::write(base.join("assets/logo.png"), b"fake").unwrap();
let err = validate_assets_tree(&base).unwrap_err();
assert!(
err.to_string().contains(CODE_UNEXPECTED_PATH),
"got {err}"
);
let _ = fs::remove_dir_all(&base);
}
}