fix: binary install is now working

pkgr/src/package/installer/errors.rs

@@ -1,21 +1,26 @@
 use std::fmt::Display;
+use std::io;
 
 #[derive(Debug)]
 pub enum BinError {
     UnpackError(String),
+    IOError(io::Error),
+    Cancelled,
 }
 
 impl Display for BinError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             BinError::UnpackError(e) => write!(f, "Unpack error: {}", e),
+            BinError::IOError(e) => write!(f, "IO error: {}", e),
+            BinError::Cancelled => write!(f, "Cancelled by user"),
         }
     }
 }
 
 #[derive(Debug)]
 pub enum BuildError {
-    InvalidManifest,
+    InvalidManifest(String),
 }
 
 impl Display for BuildError {
@@ -30,8 +35,7 @@ impl Display for BuildError {
 pub enum InstallError {
     BuildError(BuildError),
     BinError(BinError),
-    InvalidManifest,
-    Generic,
+    InvalidManifest(String),
 }
 
 impl ToString for InstallError {
@@ -39,8 +43,7 @@ impl ToString for InstallError {
         match self {
             InstallError::BuildError(e) => format!("{}", e),
             InstallError::BinError(e) => format!("{}", e),
-            InstallError::InvalidManifest => "Invalid manifest".to_string(),
-            InstallError::Generic => "Install error".to_string(),
+            InstallError::InvalidManifest(s) => format!("{}", s),
         }
     }
 }

pkgr/src/package/installer/mod.rs

@@ -1,5 +1,8 @@
-use std::fs::{remove_dir, remove_dir_all};
+use std::fs::remove_dir_all;
+use std::path::Path;
 use std::process::exit;
+use std::{io, thread};
+use libc::SIGINT;
 
 use log::{debug, error, info, trace};
 
@@ -12,8 +15,8 @@ use crate::package::identifier::{PackageIdentifier, PackageLocator};
 use crate::package::Package;
 use crate::tmpfs::TempDir;
 use crate::types::fetch::TryFetch;
-use crate::util::{visit_dirs};
-use crate::util::prompts::prompt_bool;
+use crate::util::fs::{copy_recursively, visit_dirs};
+use crate::util::prompts::{is_noninteractive, prompt_bool};
 
 pub mod errors;
 
@@ -62,29 +65,47 @@ impl PackageInstaller {
         tmpdir.push(&self.manifest.package.name);
         trace!("extracting package into: {}", tmpdir.to_string());
         if let Err(e) = self.extract_to(tmpdir.to_string()) {
-            return Err(e)
+            return Err(e);
         }
         debug!("extracted package in: {}", tmpdir.to_string());
-        if prompt_bool("See all files?", false) {
-            if let Err(e) = visit_dirs(tmpdir.path().as_path(), &|d| info!(target: "item", "{}", d.path().to_str().unwrap())) {
-                error!("Could not show files: {}", e);
+        {
+            let mut tmpdir = tmpdir.clone();
+            tmpdir.push(&self.manifest.bin.clone().unwrap().root);
+            if prompt_bool("See all pending installation files?", true) {
+                if let Err(e) = visit_dirs(tmpdir.path().as_path(),
+                                           &|d| {
+                                               info!(target: "item", "{}", d.path()
+                                                   .to_str()
+                                                   .unwrap()
+                                                   .replace(&tmpdir.to_string(), ""))
+                                           })
+                {
+                    error!("Could not show files: {}", e);
+                }
             }
-            if prompt_bool("Continue?", false) {
-                self.apply_overlay();
-            }
-        } else {
-            self.apply_overlay();
+        }
+        if !prompt_bool("Continue?", is_noninteractive()) {
+            return Err(BinError::Cancelled);
+        }
+        match self.apply_overlay() {
+            Ok(_) => Ok(()),
+            Err(e) => Err(BinError::IOError(e))
+        }
+    }
+
+    fn apply_overlay(&self) -> Result<(), io::Error> {
+        let mut tmpdir = TempDir::default();
+        tmpdir.push(&self.manifest.package.name);
+        tmpdir.push(&self.manifest.bin.clone().unwrap().root);
+        if let Err(e) = copy_recursively(&tmpdir.path(), Path::new("/")) {
+            return Err(e);
         }
         Ok(())
     }
 
-    fn apply_overlay(&self) {
-
-    }
-
     fn build(&self) -> Result<(), BuildError> {
         if let None = self.manifest.build.clone() {
-            return Err(BuildError::InvalidManifest);
+            return Err(BuildError::InvalidManifest(String::from("No build manifest")));
         }
         let build_manifest = self.manifest.build.clone().unwrap();
         // TODO: Check dependencies
@@ -117,7 +138,7 @@ impl PackageInstaller {
                 if let None = self.manifest.bin {
                     self.install_type = InstallType::Build;
                     if let None = self.manifest.build {
-                        return Err(InstallError::InvalidManifest);
+                        return Err(InstallError::InvalidManifest(String::from("no bin or build manifest")));
                     }
                 }
             }
@@ -125,7 +146,7 @@ impl PackageInstaller {
                 if let None = self.manifest.build {
                     self.install_type = InstallType::Bin;
                     if let None = self.manifest.bin {
-                        return Err(InstallError::InvalidManifest);
+                        return Err(InstallError::InvalidManifest(String::from("no build or bin manifest")));
                     }
                 }
             }