Fixed logical errors, tryed to fix tests

1 files changed, 79 insertions, 81 deletions

diff --git a/src/main.rs b/src/main.rs
index b3367f3..2bdb29c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,12 +7,14 @@ use crate::net::{http_package::HTTPPackage, i2p_package::I2PPackage};
 
 use crate::pkgtoolkit::Package;
 use crate::pkgtoolkit::index::IndexOperations;
+use crate::pkgtoolkit::git_source::GitSource;
+use crate::pkgtoolkit::archive::ArchiveOperations;
+use crate::pkgtoolkit::build::BuildOperations;
 
 use clap::{Args, Parser, Subcommand};
-use std::fs::File;
-use std::fs::create_dir_all;
 use std::io::Write;
 use std::path::Path;
+use toml;
 
 #[derive(Parser)]
 struct Cli {
@@ -70,70 +72,79 @@ struct RemoteInstallArgs {
     clean: bool,
 }
 
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Changed return type to be more general
     let cli: Cli = Cli::parse();
 
     match &cli.command {
         Commands::Validate { path } => {
             println!("Validating {}", path);
+            match Package::check(path.to_string()) {
+                Ok(is_valid) => {
+                    if is_valid {
+                        println!("Package archive is valid.");
+                    } else {
+                        println!("Package archive is invalid.");
+                        return Err(std::io::Error::other("Invalid package archive").into());
+                    }
+                }
+                Err(e) => {
+                    log::error!("Failed to validate package '{}': {}", path, e);
+                    return Err(e.into()); 
+                }
+            }
             return Ok(());
         }
         Commands::Build { pkgname } => {
-            println!("Building {}", pkgname);
+            println!("Building package from archive: {}", pkgname);
+
+            let path = Path::new(&pkgname);
+            if !path.exists() {
+                return Err(std::io::Error::other(format!("Package archive not found: {}", pkgname)).into());
+            }
+
+            if !path.is_file() {
+                return Err(std::io::Error::other(format!("Path is not a file: {}", pkgname)).into());
+            }
+
+            println!("Extracting archive...");
+            Package::extract_archive(&pkgname)?;
+
+            let config = Config::parse().unwrap(); 
+            let cache_dir = &config.paths.cache_dir;
+            let install_toml_path = Path::new(cache_dir).join("INSTALL");
+
+            if !install_toml_path.exists() {
+                return Err(std::io::Error::other("INSTALL file not found in archive").into());
+            }
+
+            let install_content = std::fs::read_to_string(&install_toml_path)?;
+            let install_data: crate::pkgtoolkit::types::Install = toml::from_str(&install_content)?;
+
+            let mut pkg = install_data.package;
+
+            println!("Building package '{}'...", pkg.name);
+            pkg.build()?;
+            println!("Package '{}' built successfully.", pkg.name);
             return Ok(());
         }
-        Commands::Install {
-            pkgname,
-            source: _,
-            args,
-        } => {
-            let config = Config::parse().unwrap();
-
+        Commands::Install { pkgname, source: _, args } => {
+            let config = Config::parse().unwrap(); 
             if args.http {
                 println!("Installing {} via HTTP", pkgname);
                 let mut http_client = HTTPPackage::new(config);
-                match http_client.fetch_index_http().await {
-                    Ok(_) => {
-                        log::info!("Index fetched successfully.");
-                    }
-                    Err(e) => {
-                        log::error!("Failed to fetch index: {}", e);
-                        return Err(e);
-                    }
-                }
-                match http_client.fetch_package_http(pkgname).await {
-                    Ok(_) => {
-                        log::info!("Package '{}' installed successfully.", pkgname);
-                    }
-                    Err(e) => {
-                        log::error!("Failed to install package '{}': {}", pkgname, e);
-                        return Err(e);
-                    }
-                }
+                http_client.fetch_index_http().await?; 
+                log::info!("Index fetched successfully.");
+                http_client.fetch_package_http(pkgname).await?;
+                log::info!("Package '{}' installed successfully.", pkgname);
             } else {
                 println!("Installing {} via I2P", pkgname);
                 let mut i2p_client = I2PPackage::new(config);
-
-                match i2p_client.fetch_index().await {
-                    Ok(_) => {
-                        log::info!("Index fetched successfully.");
-                    }
-                    Err(e) => {
-                        log::error!("Failed to fetch index: {}", e);
-                        return Err(e);
-                    }
-                }
-                match i2p_client.fetch_package(pkgname).await {
-                    Ok(_) => {
-                        log::info!("Package '{}' installed successfully.", pkgname);
-                    }
-                    Err(e) => {
-                        log::error!("Failed to install package '{}': {}", pkgname, e);
-                        return Err(e);
-                    }
-                }
+                i2p_client.fetch_index().await?; 
+                log::info!("Index fetched successfully.");
+                i2p_client.fetch_package(pkgname).await?; 
+                log::info!("Package '{}' installed successfully.", pkgname);
             }
             return Ok(());
         }
@@ -142,15 +153,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             return Ok(());
         }
         Commands::GetSource { pkgname } => {
+            let config = Config::parse().unwrap(); 
             println!("Getting source of {}", pkgname);
+
+           
+            let source_path = GitSource::get_source_by_name(pkgname, &config)?;
+            println!("Source code successfully downloaded to: {}", source_path);
             return Ok(());
         }
-        Commands::DefaultConfig {
-            repo,
-            cachedir,
-            buildir,
-            installed_db,
-        } => {
+        Commands::DefaultConfig { repo, cachedir, buildir, installed_db } => {
             println!("Generating config file");
             if cachedir.is_none() && repo.is_none() && buildir.is_none() {
                 let config = Config::default().unwrap();
@@ -162,12 +173,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 log::warn!("Writing the default config to /etc/mesk/mesk.toml");
 
                 let path = Path::new("/etc/mesk/mesk.toml");
-                create_dir_all(path.parent().unwrap())?;
-                let mut file = File::create(path)?;
+                std::fs::create_dir_all(path.parent().unwrap())?; 
+                let mut file = std::fs::File::create(path)?; 
                 file.write_all(config.as_bytes())?;
                 println!("Config tool ending work.");
             } else {
-                let config = Config::generate(repo, cachedir, buildir, installed_db).unwrap();
+                let config = Config::generate(repo, cachedir, buildir, installed_db).unwrap(); 
 
                 println!("---- Start of generated config ----");
                 println!("{:?}", config);
@@ -176,27 +187,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 log::warn!("Writing the default config to /etc/mesk/mesk.toml");
 
                 let path = Path::new("/etc/mesk/mesk.toml");
-                create_dir_all(path.parent().unwrap())?;
-                let mut file = File::create(path)?;
-                file.write_all(config.as_bytes())?;
+                std::fs::create_dir_all(path.parent().unwrap())?; 
+                let mut file = std::fs::File::create(path)?; 
+                file.write_all(config.as_bytes())?; 
                 println!("Config tool ending work.");
             }
             return Ok(());
         }
         Commands::Update => {
-            let config = Config::parse().unwrap();
+            let config = Config::parse().unwrap(); 
             println!("Updating index from {}", config.repo.repo_url);
 
             let mut i2p_client = I2PPackage::new(config);
-            match i2p_client.fetch_index().await {
-                Ok(_) => {
-                    println!("Index updated successfully.");
-                }
-                Err(e) => {
-                    log::error!("Failed to update index: {}", e);
-                    return Err(e);
-                }
-            }
+            i2p_client.fetch_index().await?; 
+            println!("Index updated successfully.");
             return Ok(());
         }
         Commands::Upgrade { pkgname } => {
@@ -208,22 +212,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 "CREATED BY: Asya and Namilsk as part of the Anthrill independent Global network distribution project"
             );
             println!("          ");
-            println!("The Anthrill project repos: https://codeberg.org/NamelessTeam  ");
+            println!("The Anthrill project repos: https://codeberg.org/NamelessTeam    ");
+            return Ok(());
         }
         Commands::GenIndex { path } => {
             println!("Generating index for {}", path);
-            match Package::gen_index(path) {
-                Ok(_) => {
-                    println!("Index generated successfully.");
-                }
-                Err(e) => {
-                    log::error!("Failed to generate index: {}", e);
-                    return Err(Box::new(e));
-                }
-            }
+
+            Package::gen_index(path)?;
+            println!("Index generated successfully.");
             return Ok(());
         }
     }
 
-    Ok(())
 }