AeroPkg/src/commands/install.rs

use std::path::Path;
use std::process;

use crate::utils::parser::{self, pkginfo};
use super::run::download::download;
use super::run::patch::patch;
use super::run::build::build;
use super::run::config::config;


pub fn install(repo: &String, pkgname: &String) -> Result<(), bool> {
    let pkg_md_path = crate::commands::get_var_path().join(format!("{}/{}.md", &repo, &pkgname));

    check_build_dependency(&repo, &pkg_md_path)?;
    check_run_dependency(&pkg_md_path)?;
    download(&repo, &pkgname)?;
    patch(&repo, &pkgname)?;
    build(&repo, &pkgname)?;
    config(&repo, &pkgname)?;

    println!("Package {} installed successfully from repo {}", pkgname, repo);
    Ok(())
}

fn check_build_dependency(repo: &String, pkg_md_path: &Path) -> Result<(), bool> {
    let deps = match parser::get_build_deps(&pkg_md_path) {
        Ok(deps) => deps,
        Err(_) => { return Ok(()) }
    };

    for dependency in deps.lines() {
        if !dependency.trim().is_empty() {
            if !super::get_aeropkg_base().join(repo).join(dependency).exists() {
                match install(repo, &dependency.to_string()) {
                    Ok(()) => {}
                    Err(_) => {process::exit(1) }
                }
            }
        }
    }

    Ok(())
}

fn check_run_dependency(pkg_md_path: &Path) -> Result<(), bool> {
    let deps = match parser::get_run_deps(pkg_md_path) {
        Ok(deps) => deps,
        Err(_) => { return Ok(()) }
    };

    let repo_list = parser::repoinfo::get_repo_list();

    for pkgname in deps.split_whitespace() {
        let mut found = false;

        for repo_name in &repo_list {
            let path = super::get_aeropkg_base().join(repo_name).join(pkgname);
            if path.exists() {
                found = true;
                break;
            }
        }

        if !found {
            install(&pkginfo::get_priority_repo(pkgname.to_string()), &pkgname.to_string());
        }
    }

    Ok(())
}