ableos_time/repbuild/src/dev.rs

#![allow(unused)]
use std::{
    fmt::format,
    fs::{read_to_string, File},
    io::{BufWriter, Write},
    process::exit,
};

use {error_stack::Report, hblang::Options};

use crate::Error;
pub struct Package {
    name:      String,
    binaries:  Vec<String>,
    build_cmd: String,
}

impl Package {
    pub fn load_from_file(path: String) -> Self {
        let contents = match std::fs::read_to_string(path.clone()) {
            // If successful return the files text as `contents`.
            // `c` is a local variable.
            Ok(c) => c,
            // Handle the `error` case.
            Err(_) => {
                // Write `msg` to `stderr`.
                eprintln!("Could not read file `{}`", path);
                // Exit the program with exit code `1`.
                exit(1);
            }
        };
        use toml::Value;

        let mut data: Value = toml::from_str(&contents).unwrap();
        let mut name = data
            .get("package")
            .unwrap()
            .get("name")
            .unwrap()
            .to_string();
        name.pop();
        name.remove(0);

        let dependants = data.get("dependants").unwrap();
        let bin_table = dependants.get("binaries").unwrap().as_table().unwrap();
        let mut binaries = vec![];

        for (count, (name, table)) in bin_table.into_iter().enumerate() {
            // if count != 0 {
            println!("{}", name);
            binaries.push(name.clone());
            // }
        }
        let build_table = data.get("build").unwrap();

        let mut build_cmd: String = build_table.get("command").unwrap().as_str().unwrap().into();
        build_cmd.remove(0);
        // build_cmd.pop();

        Self {
            name,
            binaries,
            build_cmd,
        }
    }
    pub fn build(&self) {
        if self.binaries.contains(&"hblang".to_string()) {
            let file = self.build_cmd.split_ascii_whitespace().last().unwrap();

            let path = format!("sysdata/programs/{}/{}", self.name, file);
            let mut bytes = Vec::new();
            // compile here

            let _ = hblang::run_compiler(
                &path,
                Options {
                    fmt: true,
                    ..Default::default()
                },
                &mut bytes,
            );
            let _ = hblang::run_compiler(&path, Default::default(), &mut bytes);

            match std::fs::create_dir("target/programs") {
                Ok(_) => (),
                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => (),
                Err(e) => panic!("{}", e),
            }
            std::fs::write(format!("target/programs/{}.hbf", self.name), &bytes).unwrap();
            bytes.clear();
            let _ = hblang::run_compiler(
                &path,
                Options {
                    dump_asm: true,
                    ..Default::default()
                },
                &mut bytes,
            );
            std::fs::write(format!("target/programs/{}.hba", self.name), &bytes).unwrap();
        }
    }
}