Asset pipeline for Rust

// build.rs
use sha1::{Digest, Sha1};
use std::collections::HashMap;
use std::fs;
use std::io::Write;
use std::path::Path;
use walkdir::WalkDir;

fn main() -> Result<(), anyhow::Error> {
    // Place the directory containing your asset files here
    let assets_dir = Path::new("assets");

    // The output directory
    let dest_path = Path::new("./").join("public/assets");
    fs::remove_dir_all(&dest_path).ok();
    fs::create_dir_all(&dest_path).expect("Can't create directory");

    let mut asset_map = HashMap::new();

    WalkDir::new(assets_dir).into_iter().for_each(|entry| {
        let Ok(entry) = entry else { return; };

        if !entry.file_type().is_file() {
            return;
        };

        let file_name = entry.file_name().to_string_lossy().to_string();
        let root_file = entry
            .path()
            .file_stem()
            .unwrap()
            .to_string_lossy()
            .to_string();
        let extension = entry
            .path()
            .extension()
            .unwrap()
            .to_string_lossy()
            .to_string();

        if ["woff", "woff2"].contains(&extension.as_str()) {
            // Those file already have hashes in their filenames
            let source = entry.path().to_string_lossy().to_string();
            let dest = dest_path.join(&file_name).to_string_lossy().to_string();
            fs::copy(source, dest).expect("Can't copy file");
            return;
        }

        let file_content = fs::read_to_string(entry.path()).expect("Can't read file");

        let hash = calculate_sha1(file_content.as_str());
        let new_filename = format!("{}.{}.{}", root_file, hash, extension);

        let source = entry.path().to_string_lossy().to_string();
        let dest = dest_path.join(&new_filename).to_string_lossy().to_string();

        fs::copy(source, dest).expect("Can't copy file");

        // Keep track of old and new filenames
        asset_map.insert(file_name, new_filename);
    });

    // Write the map to a manifest.json
    let mut file = fs::File::create(Path::new(&dest_path).join("manifest.json"))
        .expect("Can't write asset_map.rs");

    let data = serde_json::to_string(&asset_map)?;

    file.write_all(data.as_bytes())
        .expect("Can't write content");

    Ok(())
}

fn calculate_sha1(input: &str) -> String {
    let mut hasher = Sha1::new();
    hasher.update(input);
    let result = hasher.finalize();
    format!("{:x}", result)
}

// assets_decorator.rs
use std::path::Path;
use std::{collections::HashMap, fs::File, io::Read};

const DIR: &str = "public/assets";
const PUBLIC_DIR: &str = "/assets";

pub fn asset_path(filename: &str) -> Result<String, anyhow::Error> {
    let mut file_content = String::new();
    let mut file = File::open(format!("{}/manifest.json", DIR))?;
    file.read_to_string(&mut file_content)?;

    let data: HashMap<String, String> = serde_json::from_str(&file_content)?;

    match data.get(filename) {
        Some(filename) => Ok(format!("{}/{}", PUBLIC_DIR, filename)),
        None => Err(anyhow::anyhow!("Asset not found")),
    }
}

pub fn asset_tag(filename: &str) -> String {
    let filename = match asset_path(filename) {
        Ok(path) => path,
        Err(_) => return Default::default(),
    };
    let extension = Path::new(&filename)
        .extension()
        .expect("Can't get filename extension")
        .to_string_lossy()
        .to_string();

    match extension.as_str() {
        "js" => format!("<script src=\"{}\"></script>", filename),
        "css" => format!("<link rel=\"stylesheet\" href=\"{}\">", filename),
        _ => Default::default(),
    }
}