fix: remove useless threading

pkgr/src/package/identifier.rs

@@ -128,3 +128,36 @@ impl FromStr for PackageLocator {
         })
     }
 }
+
+impl From<(String, String)> for PackageLocator {
+    fn from((name, locate_str): (String, String)) -> Self {
+        // name = "pkg"
+        // locate_str = "1.0.0:tag1,tag2" or "1.0.0" or "tag1,tag2"
+        let mut version = None;
+        let mut tags = None;
+
+        let version_re = Regex::new("^([0-9]+)").unwrap();
+        let tags_re = Regex::new("^:([a-zA-Z0-9,._]+)").unwrap();
+
+        if let Some(caps) = version_re.captures(locate_str.as_str()) {
+            version = Some(caps.get(1).unwrap().as_str().parse::<u32>().unwrap());
+        }
+
+        if let Some(caps) = tags_re.captures(locate_str.as_str()) {
+            tags = Some(
+                caps.get(1)
+                    .unwrap()
+                    .as_str()
+                    .split(",")
+                    .map(|s| s.to_string())
+                    .collect(),
+            );
+        }
+
+        PackageLocator {
+            name,
+            version,
+            tags,
+        }
+    }
+}

pkgr/src/package/installer/errors.rs

@@ -30,6 +30,7 @@ impl Display for BuildError {
 pub enum InstallError {
     BuildError(BuildError),
     BinError(BinError),
+    InvalidManifest,
     Generic,
 }
 
@@ -38,6 +39,7 @@ impl ToString for InstallError {
         match self {
             InstallError::BuildError(e) => format!("Build error: {}", e),
             InstallError::BinError(e) => format!("Bin error: {}", e),
+            InstallError::InvalidManifest => "Invalid manifest".to_string(),
             InstallError::Generic => "Install error".to_string(),
         }
     }

pkgr/src/package/installer/mod.rs

@@ -1,9 +1,13 @@
 use crate::tmpfs::TempDir;
 use errors::{BinError, BuildError, InstallError};
-use log::{debug, trace};
+use log::{debug, error, info, trace};
 use manifest::Manifest;
 use pkgfile::PKGFile;
 use std::fmt::Display;
+use std::process::exit;
+use crate::CONFIG;
+use crate::package::identifier::{PackageIdentifier, PackageLocator};
+use crate::package::Package;
 
 pub mod errors;
 
@@ -59,14 +63,54 @@ impl PackageInstaller {
         }
         let build_manifest = self.manifest.build.clone().unwrap();
         // TODO: Check dependencies
+        for pkg_tuple in build_manifest.dependencies {
+            let mut pkg = Package::fetch(
+                PackageIdentifier::PackageLocator(
+                    PackageLocator::from(pkg_tuple)
+                )
+            ).expect("no pkg");
+
+            if !pkg.is_installed() {
+                match pkg.install(CONFIG.with(|c| {
+                    c.build_by_default
+                })) {
+                    Ok(_) => { info!("Installed dependency: \"{}\"", pkg.manifest().package.name) },
+                    Err(_) => {
+                        error!("Could not install dependency: \"{}\"", pkg.identifier);
+                        exit(1);
+                    }
+                }
+            }
+        }
 
         Ok(())
     }
 
-    pub fn install(&self) -> Result<(), InstallError> {
+    pub fn install(&mut self) -> Result<(), InstallError> {
         match self.install_type {
-            InstallType::Bin => self.bin().map_err(|e| InstallError::BinError(e)),
-            InstallType::Build => self.build().map_err(|e| InstallError::BuildError(e)),
+            InstallType::Bin => {
+                if let None = self.manifest.bin {
+                    self.install_type = InstallType::Build;
+                    if let None = self.manifest.build {
+                        return Err(InstallError::InvalidManifest);
+                    }
+                }
+            }
+            InstallType::Build => {
+                if let None = self.manifest.build {
+                    self.install_type = InstallType::Bin;
+                    if let None = self.manifest.bin {
+                        return Err(InstallError::InvalidManifest);
+                    }
+                }
+            }
+        }
+
+        match self.install_type {
+            InstallType::Bin => self.bin()
+                .map_err(|e| InstallError::BinError(e)),
+            InstallType::Build => self.build()
+                .map_err(|e| InstallError::BuildError(e)),
         }
     }
 }

pkgr/src/package/mod.rs

@@ -1,4 +1,4 @@
-use log::trace;
+use log::{info, trace};
 
 pub mod fetch;
 pub mod identifier;
@@ -51,12 +51,26 @@ impl Package {
     }
 
     /// Install the package.
-    pub fn install(&mut self) -> Result<(), installer::errors::InstallError> {
+    pub fn install(&mut self, build: bool) -> Result<(), installer::errors::InstallError> {
         let manifest = self.manifest();
-        let installer = installer::PackageInstaller::new(
+        let mut installer = installer::PackageInstaller::new(
             manifest.clone(),
             self.pkgfile.clone(),
-            installer::InstallType::Bin,
+            if build {
+                info!("building package: {}...", if self.manifest().package.name.is_empty() {
+                    self.identifier.to_string()
+                } else {
+                    self.manifest().package.name
+                });
+                installer::InstallType::Build
+            } else {
+                info!("using binary install for package: {}...", if self.manifest().package.name.is_empty() {
+                    self.identifier.to_string()
+                } else {
+                    self.manifest().package.name
+                });
+                installer::InstallType::Bin
+            },
         );
         match installer.install() {
             Ok(_) => {