AeroPkg/src/commands/run/build.rs

use std::fs;

use crate::utils::parser::{self, env::get_install_env};
use crate::utils::shell::{run_install_script,run_install_script_hook};
use crate::commands::link::link;
use super::download::download;
use super::patch::patch;


pub fn build(repo: &String, pkgname: &String) {
    let pkgpath = &crate::commands::get_aeropkg_base().join(repo).join(pkgname);
    fs::create_dir_all(&pkgpath).ok();
    let src = &pkgpath.join("src");

    let pkg_md_path = &crate::commands::get_aeropkg_var().join(format!("{}/{}.md", repo, pkgname));
    let builded_pkg_md_path = &crate::commands::get_aeropkg_base().join(repo).join(pkgname).join("build-script.md");

    let build_script = match parser::get_build_script(pkg_md_path) {
        Ok(script) => script,
        Err(error) => {
            panic!("Failed to parse build script: {}", error);
        }
    };
    if builded_pkg_md_path.exists() {
        let builded_script = match parser::get_build_script(builded_pkg_md_path) {
            Ok(script) => script,
            Err(error) => {
                panic!("Failed to parse build block from {}: {}", builded_pkg_md_path.to_string_lossy(), error);
            }
        };
        if build_script == builded_script { return }
    }
    
    if src.join(".aeropkg.applied-build").exists() {
        let src_build = fs::read_to_string(src.join(".aeropkg.applied-build")).unwrap_or("".to_string());
        if build_script == src_build {
            return
        } else {
            fs::remove_dir_all(src).unwrap();
            download(repo, pkgname);
            patch(repo, pkgname)
        }
    }

    let full_env = get_install_env(repo, pkgname, pkg_md_path, "build");
    run_install_script(&build_script, src, &full_env);
    run_install_script_hook(repo, "build", &full_env);

    let dest_dir = crate::commands::get_aeropkg_base().join(repo).join(pkgname);
    if let Err(e) = fs::create_dir_all(&dest_dir) { panic!("Failed to create destination directory: {}", e) }
    let dest_path = &dest_dir.join("build-script.md");
    fs::remove_file(dest_path).ok();
    if let Err(e) = fs::hard_link(pkg_md_path, dest_path) { panic!("Failed to copy build script to destination: {}", e) }
    fs::write(src.join(".aeropkg.applied-build"), &build_script).unwrap();


    let save_source_flag = full_env.get("save_source").is_some();
    if !save_source_flag {
        if let Err(e) = fs::remove_dir_all(&src) { panic!("Failed to remove source directory: {}", e) }
    }

    hook(repo, pkgname);

    if !full_env.get("disable").is_some() { 
        let _ = fs::File::create(crate::commands::get_aeropkg_base().join(repo).join(pkgname).join("disabled"));
    } else {
        link(repo, pkgname)
    }
}


fn hook(repo: &String, pkgname: &String) {
    let pkg_dir = crate::commands::get_aeropkg_base().join(repo).join(pkgname);
    let lib_dir = &pkg_dir.join("lib");
    let lib64_dir = &pkg_dir.join("lib64");
    let lib32_dir = &pkg_dir.join("lib32");
    crate::utils::fs::mv::mv(&lib64_dir, &lib_dir).ok();
    crate::utils::fs::mv::mv(&lib32_dir, &lib_dir).ok();
    fs::remove_dir_all(&lib64_dir).ok();
    fs::remove_dir_all(&lib32_dir).ok();
}