refactor(collection): rename root_path to collection

Prepare to make collection dynamic

src/cli.rs

@@ -93,9 +93,9 @@ pub enum Commands {
     /// List all available packages
     #[clap(name = "list", alias = "ls")]
     ListPackages {
-        /// Root path of packages
+        /// Which collection to get the packages from
         #[arg(required = false)]
-        root_path: Option<String>,
+        collection: Option<String>,
     },
 
     /// Inspect package build log

src/lib.rs

@@ -80,8 +80,8 @@ pub async fn init() -> Result<()> {
         Commands::Query { query } => {
             registry.query(&query).await?;
         }
-        Commands::ListPackages { root_path } => {
-            registry.list(root_path.as_deref()).await?;
+        Commands::ListPackages { collection } => {
+            registry.list(collection.as_deref()).await?;
         }
         Commands::Inspect { package } => {
             registry.inspect(&package).await?;

src/registry/installed.rs

@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::{collections::HashMap, path::Path};
 
 use anyhow::{Context, Result};
 use chrono::{DateTime, Utc};
@@ -14,15 +14,12 @@ use crate::{
     registry::package::parse_package_query,
 };
 
-use super::{
-    package::{ResolvedPackage, RootPath},
-    storage::PackageStorage,
-};
+use super::{package::ResolvedPackage, storage::PackageStorage};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct InstalledPackage {
     pub repo_name: String,
-    pub root_path: RootPath,
+    pub collection: String,
     pub name: String,
     pub bin_name: String,
     pub version: String,
@@ -66,23 +63,23 @@ impl InstalledPackages {
     pub fn is_installed(&self, package: &ResolvedPackage) -> bool {
         self.packages.iter().any(|installed| {
             installed.repo_name == package.repo_name
-                && installed.root_path == package.root_path
+                && installed.collection == package.collection.to_string()
                 && installed.name == package.package.full_name('-')
         })
     }
 
     fn find_package_mut(&mut self, package: &ResolvedPackage) -> Option<&mut InstalledPackage> {
         self.packages.iter_mut().find(|installed| {
             installed.repo_name == package.repo_name
-                && installed.root_path == package.root_path
+                && installed.collection == package.collection.to_string()
                 && installed.name == package.package.full_name('-')
         })
     }
 
     pub fn find_package(&self, package: &ResolvedPackage) -> Option<&InstalledPackage> {
         self.packages.iter().find(|installed| {
             installed.repo_name == package.repo_name
-                && installed.root_path == package.root_path
+                && installed.collection == package.collection.to_string()
                 && installed.name == package.package.full_name('-')
         })
     }
@@ -99,7 +96,7 @@ impl InstalledPackages {
         } else {
             let new_installed = InstalledPackage {
                 repo_name: resolved_package.repo_name.to_owned(),
-                root_path: resolved_package.root_path.to_owned(),
+                collection: resolved_package.collection.to_string().to_owned(),
                 name: package.full_name('-'),
                 bin_name: package.bin_name,
                 version: package.version,
@@ -120,7 +117,7 @@ impl InstalledPackages {
             true => {
                 self.packages.retain(|installed| {
                     !(installed.repo_name == resolved_package.repo_name
-                        && installed.root_path == resolved_package.root_path
+                        && installed.collection == resolved_package.collection.to_string()
                         && installed.name == resolved_package.package.full_name('-'))
                 });
             }
@@ -155,10 +152,7 @@ impl InstalledPackages {
         packages: Option<&[String]>,
         package_store: &PackageStorage,
     ) -> Result<()> {
-        let mut total_base = (0, 0);
-        let mut total_bin = (0, 0);
-        let mut total_pkg = (0, 0);
-        let mut total = (0, 0);
+        let mut total: HashMap<String, (u32, u64)> = HashMap::new();
 
         let resolved_packages = packages
             .map(|pkgs| {
@@ -182,7 +176,7 @@ impl InstalledPackages {
         resolved_packages.iter().for_each(|package| {
             println!(
                 "- [{}] {1}:{1}-{2} ({3}) ({4})",
-                package.root_path.clone().color(Color::BrightGreen),
+                package.collection.clone().color(Color::BrightGreen),
                 package.name.clone().color(Color::Blue),
                 package.version.clone().color(Color::Green),
                 package
@@ -192,38 +186,36 @@ impl InstalledPackages {
                 format_bytes(package.size).color(Color::Magenta)
             );
 
-            match package.root_path {
-                RootPath::Bin => total_bin = (total_bin.0 + 1, total_bin.1 + package.size),
-                RootPath::Base => total_base = (total_base.0 + 1, total_base.1 + package.size),
-                RootPath::Pkg => total_pkg = (total_pkg.0 + 1, total_pkg.1 + package.size),
-            }
-            total = (total.0 + 1, total.1 + package.size);
+            let (count, size) = total.get(&package.collection).unwrap_or(&(0, 0));
+            total.insert(
+                package.collection.to_owned(),
+                (count + 1, size + package.size),
+            );
         });
         println!();
         println!("{:<2} Installed:", "");
-        println!(
-            "{:<4} base: {} ({})",
-            "",
-            total_base.0.color(Color::BrightGreen),
-            format_bytes(total_base.1)
-        );
-        println!(
-            "{:<4} bin: {} ({})",
-            "",
-            total_bin.0.color(Color::BrightBlue),
-            format_bytes(total_bin.1)
-        );
-        println!(
-            "{:<4} pkg: {} ({})",
-            "",
-            total_pkg.0.color(Color::BrightRed),
-            format_bytes(total_pkg.1)
-        );
+
+        for (collection, (count, size)) in total.iter() {
+            println!(
+                "{:<4} {}: {} ({})",
+                "",
+                collection,
+                count.color(Color::BrightGreen),
+                format_bytes(size.to_owned())
+            );
+        }
+
+        let (count, value) = total
+            .values()
+            .fold((0, 0), |(count_acc, value_acc), &(count, value)| {
+                (count_acc + count, value_acc + value)
+            });
+
         println!(
             "{:<2} Total: {} ({})",
             "",
-            total.0.color(Color::BrightYellow),
-            format_bytes(total.1)
+            count.color(Color::BrightYellow),
+            format_bytes(value)
         );
 
         Ok(())

src/registry/mod.rs

@@ -7,7 +7,7 @@ use futures::future::try_join_all;
 use installed::InstalledPackages;
 use loader::RegistryLoader;
 use package::{
-    image::PackageImage, parse_package_query, update::Updater, ResolvedPackage, RootPath,
+    image::PackageImage, parse_package_query, update::Updater, ResolvedPackage, Collection,
 };
 use serde::Deserialize;
 use storage::{PackageStorage, RepositoryPackages};
@@ -161,7 +161,7 @@ impl PackageRegistry {
                 println!(
                     "[{}] [{}] {}: {}",
                     installed,
-                    pkg.root_path.clone().color(Color::BrightGreen),
+                    pkg.collection.clone().color(Color::BrightGreen),
                     pkg.package.full_name('/').color(Color::Blue),
                     pkg.package.description,
                 );
@@ -187,7 +187,7 @@ impl PackageRegistry {
                 "{} ({}#{})",
                 package.name.clone().color(Color::BrightGreen),
                 package.clone().full_name('/').color(Color::BrightCyan),
-                pkg.root_path.clone().color(Color::BrightRed)
+                pkg.collection.clone().color(Color::BrightRed)
             );
             let mut data: Vec<(&str, String)> = vec![
                 ("Name", formatted_name),
@@ -319,21 +319,21 @@ impl PackageRegistry {
         installed_guard.info(package_names, &self.storage).await
     }
 
-    pub async fn list(&self, root_path: Option<&str>) -> Result<()> {
-        let root_path = match root_path {
+    pub async fn list(&self, collection: Option<&str>) -> Result<()> {
+        let collection = match collection {
             Some(rp) => match rp.to_lowercase().as_str() {
-                "base" => Ok(Some(RootPath::Base)),
-                "bin" => Ok(Some(RootPath::Bin)),
-                "pkg" => Ok(Some(RootPath::Pkg)),
+                "base" => Ok(Some(Collection::Base)),
+                "bin" => Ok(Some(Collection::Bin)),
+                "pkg" => Ok(Some(Collection::Pkg)),
                 _ => Err(anyhow::anyhow!(
-                    "Invalid root path: {}",
+                    "Invalid collection: {}",
                     rp.color(Color::BrightGreen)
                 )),
             },
             None => Ok(None),
         }?;
 
-        let packages = self.storage.list_packages(root_path);
+        let packages = self.storage.list_packages(collection);
         for resolved_package in packages {
             let package = resolved_package.package.clone();
             let variant_prefix = package
@@ -349,7 +349,7 @@ impl PackageRegistry {
             println!(
                 "[{0}] [{1}] {2}{3}:{3}-{4} ({5})",
                 install_prefix.color(Color::Red),
-                resolved_package.root_path.color(Color::BrightGreen),
+                resolved_package.collection.color(Color::BrightGreen),
                 variant_prefix.color(Color::Blue),
                 package.name.color(Color::Blue),
                 package.version.color(Color::Green),
@@ -414,7 +414,7 @@ pub fn select_package_variant(packages: &[ResolvedPackage]) -> Result<&ResolvedP
         println!(
             "  [{}] [{}] {}: {}",
             i + 1,
-            package.root_path.clone().color(Color::BrightGreen),
+            package.collection.clone().color(Color::BrightGreen),
             package.package.full_name('/').color(Color::Blue),
             package.package.description
         );

src/registry/package/appimage.rs

@@ -126,21 +126,26 @@ pub async fn remove_applinks(name: &str, bin_name: &str, file_path: &Path) -> Re
     let home_data = home_data_path();
     let data_path = Path::new(&home_data);
 
-    let original_icon_path = file_path.with_extension("png");
-    let (w, h) = image::image_dimensions(&original_icon_path)?;
-    let icon_path = data_path
-        .join("icons")
-        .join("hicolor")
-        .join(format!("{}x{}", w, h))
-        .join("apps")
-        .join(bin_name)
-        .with_extension("png");
     let desktop_path = data_path
         .join("applications")
         .join(format!("{name}-soar.desktop"));
 
     remove_link(&desktop_path).await?;
-    remove_link(&icon_path).await?;
+
+    let original_icon_path = file_path.with_extension("png");
+    if original_icon_path.exists() {
+        let (w, h) = image::image_dimensions(&original_icon_path)?;
+
+        let icon_path = data_path
+            .join("icons")
+            .join("hicolor")
+            .join(format!("{}x{}", w, h))
+            .join("apps")
+            .join(bin_name)
+            .with_extension("png");
+
+        remove_link(&icon_path).await?;
+    }
 
     Ok(())
 }

src/registry/package/image.rs

@@ -119,7 +119,7 @@ impl PackageImage {
             Ok(icon) => icon,
             Err(_) => load_default_icon(&format!(
                 "{}-{}.png",
-                resolved_package.repo_name, resolved_package.root_path
+                resolved_package.repo_name, resolved_package.collection
             ))
             .await
             .unwrap_or_default(),

src/registry/package/install.rs

@@ -15,7 +15,7 @@ use crate::{
         installed::InstalledPackages,
         package::{
             appimage::{check_user_ns, extract_appimage, setup_portable_dir},
-            RootPath,
+            Collection,
         },
     },
     warn,
@@ -169,7 +169,7 @@ impl Installer {
 
         self.save_file().await?;
         self.symlink_bin(&installed_packages).await?;
-        if self.resolved_package.root_path == RootPath::Pkg {
+        if self.resolved_package.collection == Collection::Pkg {
             extract_appimage(package, &self.install_path).await?;
             setup_portable_dir(
                 &package.bin_name,
@@ -201,7 +201,7 @@ impl Installer {
             );
         }
 
-        if self.resolved_package.root_path == RootPath::Pkg {
+        if self.resolved_package.collection == Collection::Pkg {
             check_user_ns().await;
         }