Created minimal package validation here. Writed documentations comments (///)

3 files changed, 99 insertions, 17 deletions

diff --git a/src/cfg/config.rs b/src/cfg/config.rs
index 45be37d..8672433 100644
--- a/src/cfg/config.rs
+++ b/src/cfg/config.rs
@@ -13,39 +13,45 @@ pub enum Loglevel {
     Error
 }
 
+
+/// `mesk.toml` configuration fields here
 #[derive(Deserialize, Debug, Serialize)]
 pub struct Config {
-    repo:     Repo,
-    log:      Log,
-    paths:    Paths,
+    pub repo:     Repo,
+    pub log:      Log,
+    pub paths:    Paths,
 }
 
 #[derive(Deserialize, Debug, Serialize)]
 pub struct Log {
     #[serde(rename = "log_file")]
-    log_file: String,
+    pub log_file: String,
     #[serde(rename = "log_level")]
-    log_level: Loglevel,
+    pub log_level: Loglevel,
 }
 
 // Rename needed for editing mesk.toml file fields but dont touch code. 
 #[derive(Deserialize, Debug, Serialize)]
 pub struct Repo {
     #[serde(rename = "repo_url")] 
-    repo_url: String,
+    pub repo_url: String,
     #[serde(rename = "auto_update")] 
-    auto_update: bool,
+    pub auto_update: bool,
 }
 
 #[derive(Deserialize, Debug, Serialize)]
 pub struct Paths {
     #[serde(rename = "cache_dir")] 
-    cache_dir: String,
+    pub cache_dir: String,
     #[serde(rename = "build_dir")] 
-    build_dir: String,
+    pub build_dir: String,
 }
 
 impl Config {
+
+    /// Parse the /etc/mesk.toml file and return the Config object.
+    ///
+    /// This function reads the /etc/mesk.toml file, parses it and returns the Config object.
     pub fn parse() -> Result<Config, toml::de::Error> {
         let contents = fs::read_to_string("/etc/mesk.toml").unwrap();
         let result: Config = toml::from_str(&contents)?;
@@ -53,6 +59,9 @@ impl Config {
     }
 
 
+    /// Return the default configuration as a toml string.
+    ///
+    /// This function returns the default configuration as a toml string.
     pub fn default() -> Result<String, toml::ser::Error> {
         let default: Config = Config {
             repo: Repo {
diff --git a/src/main.rs b/src/main.rs
index a2ca713..a2d4aa0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,8 +2,8 @@ mod cfg;
 mod i2impl;
 mod pkgtoolkit;
 
-use crate::cfg::config;
-use crate::pkgtoolkit::pkgtools;
+use crate::cfg::config::Config;
+use crate::pkgtoolkit::pkgtools::Package;
 use crate::i2impl::mi2p; 
 
 fn main() {
diff --git a/src/pkgtoolkit/pkgtools.rs b/src/pkgtoolkit/pkgtools.rs
index d124c2b..7197d9e 100644
--- a/src/pkgtoolkit/pkgtools.rs
+++ b/src/pkgtoolkit/pkgtools.rs
@@ -1,13 +1,86 @@
-use std::fs::File; 
-use tar::Archive; 
+use crate::cfg::config::Config;
 
-pub struct Package { 
-    BuildScript: String, 
-    Name: String, 
-    Version: String
+use std::fs::{File, create_dir_all};
+use std::path::Path;
+use flate2::read::GzDecoder;
+use tar::Archive;
+
+pub enum arch {
+    x86_64,
+    aarch64,
+    x86,
+}
+
+pub struct Package {
+    name: String, 
+    version: String, 
+    arch: arch, 
+    descr: String,
 }
 
 impl Package { 
+    
+    /// Checks if the archive contains INSTALL, SETTS and BUILD files.
+    ///
+    /// Checks if INSTALL file exists and is not empty. If it does not exist or is empty, returns an error.
+    ///
+    /// Checks if SETTS and BUILD files exist and are not empty. If they do not exist or are empty, logs a warning.
+    /// 
+    /// * Returns an error if INSTALL file does not exist or is empty.
+    /// * Returns an error if INSTALL file is empty.
+    ///
+    // TODO: Add meta-files validation here. 
+    pub fn check(path_to_archive: String) -> Result<bool, std::io::Error> {
+    let config: Config = Config::parse().unwrap(); 
+
+    create_dir_all(&config.paths.cache_dir)?;
+
+    let file = File::open(&path_to_archive)?;
+    let gz = GzDecoder::new(file);
+    let mut archive = Archive::new(gz);
+
+    archive.unpack(&config.paths.cache_dir)?;
+
+    let install_path = Path::new(&config.paths.cache_dir).join("INSTALL");
+    let setts_path = Path::new(&config.paths.cache_dir).join("SETTS");
+    let build_path = Path::new(&config.paths.cache_dir).join("BUILD");
+
+    if !install_path.exists() {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "INSTALL file not found in archive",
+        ));
+    }
+
+    let install_content = std::fs::read_to_string(&install_path)?;
+    if install_content.trim().is_empty() {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            "INSTALL file is empty",
+        ));
+    }
+
+    if !setts_path.exists() {
+        log::warn!("SETTS file not found in archive. Make sure you dont need this.");
+    } else {
+        let setts_content = std::fs::read_to_string(&setts_path)?;
+        if setts_content.trim().is_empty() {
+            log::warn!("SETTS file is empty. Make sure you dont need this.");
+        }
+    }
+
+    if !build_path.exists() {
+        log::warn!("BUILD file not found in archive. Make sure you dont need this.");
+    } else {
+        let build_content = std::fs::read_to_string(&build_path)?;
+        if build_content.trim().is_empty() {
+            log::warn!("BUILD file is empty. Make sure you dont need this.");
+        }
+    }
+
+    Ok(true)
+}
+
     pub fn build() -> Result<bool, std::io::Error> {
         todo!();  
     }