feat: implement packagequeue

pkgr/src/package/mod.rs

@@ -1,20 +1,24 @@
 use std::fmt::Display;
 use std::path::Path;
+use std::process::exit;
 
-use log::{debug, info, trace};
+use log::{debug, error, info, trace};
 use reqwest::blocking::get;
 
+use manifest::build::Build;
 use pkgfile::PKGFile;
 
-use crate::package::identifier::PackageIdentifier;
+use crate::package::identifier::{PackageIdentifier, PackageLocator};
 use crate::types::fetch::TryFetch;
 
 pub mod identifier;
 pub mod installer;
+pub mod queue;
 
+#[derive(Eq, PartialEq)]
 pub struct Package {
-    pub identifier: identifier::PackageIdentifier,
-    pub pkgfile: pkgfile::PKGFile,
+    pub identifier: PackageIdentifier,
+    pub pkgfile: PKGFile,
     is_installed: bool,
     is_indexed: bool,
 }
@@ -35,6 +39,55 @@ impl Package {
         manifest::Manifest::try_from(self.pkgfile.manifest.clone()).unwrap()
     }
 
+    /// Get package dependencies
+    pub fn dependencies(&self) -> Vec<Package> {
+        let mut dependencies = vec![];
+        for dependency in self.manifest().dependencies {
+            let pkglocate = if let Ok(pl) = PackageLocator::try_from(dependency.clone()) {
+                trace!("parsed pl successfully...");
+                pl
+            } else {
+                error!("Could not parse package locator: {:?} in dependencies.", &dependency);
+                exit(1);
+            };
+            let pkg = match Package::try_fetch(PackageIdentifier::PackageLocator(pkglocate)) {
+                Ok(p) => p,
+                Err(e) => {
+                    error!("Could not fetch dependency: {}", e);
+                    exit(1);
+                }
+            };
+            dependencies.push(pkg);
+        }
+        dependencies
+    }
+
+    pub fn build_dependencies(&self) -> Vec<Package> {
+        let mut dependencies = vec![];
+        for dependency in self
+            .manifest()
+            .build
+            .unwrap_or(Build::default())
+            .dependencies {
+            let pkglocate = if let Ok(pl) = PackageLocator::try_from(dependency.clone()) {
+                trace!("parsed pl successfully...");
+                pl
+            } else {
+                error!("Could not parse package locator: {:?} in dependencies.", &dependency);
+                exit(1);
+            };
+            let pkg = match Package::try_fetch(PackageIdentifier::PackageLocator(pkglocate)) {
+                Ok(p) => p,
+                Err(e) => {
+                    error!("Could not fetch dependency: {}", e);
+                    exit(1);
+                }
+            };
+            dependencies.push(pkg);
+        }
+        dependencies
+    }
+
     /// Install the package.
     pub fn install(&mut self, build: bool) -> Result<(), installer::errors::InstallError> {
         let manifest = self.manifest();
@@ -119,7 +172,7 @@ impl TryFetch<PackageIdentifier> for Package {
                         if let Ok(b) = response.bytes() {
                             bytes.extend(b);
                         }
-                    },
+                    }
                     Err(e) => return Err(FetchError::HTTPError(e)),
                 };
                 // parse bytes as PKGFile