fix: remove useless threading

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)),
         }
     }
 }