k2f_package 0.1.0

K2F ZIP package pack/verify/sign
Documentation
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(())
}

/// Reject non-json files under content/.
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(())
}

/// Reject asset files outside `assets/fonts/`, `assets/images/`, and `assets/data/`.
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);
    }
}