fix most clippy pedantic warnings

3 files changed, 55 insertions, 63 deletions

diff --git a/src/gentoo/package.rs b/src/gentoo/package.rs
index d1596f7..1d41b8c 100644
--- a/src/gentoo/package.rs
+++ b/src/gentoo/package.rs
@@ -56,11 +56,11 @@ pub struct InstalledPackage {
 pub struct Package {
     pub atom: PackageKey,
 
-    pub versions: Vec<Version>,
+    pub versions: Vec<PackageVersion>,
 }
 
 #[derive(Debug, Clone)]
-pub struct Version {
+pub struct PackageVersion {
     pub version: String,
 
     pub metadata: Metadata,
diff --git a/src/gentoo/portage.rs b/src/gentoo/portage.rs
index 9b13867..779f746 100644
--- a/src/gentoo/portage.rs
+++ b/src/gentoo/portage.rs
@@ -7,50 +7,50 @@ use crate::gentoo::{
 
 #[derive(Debug, Default)]
 pub struct Portage {
-    installed_packages: Vec<InstalledPackage>,
-    world_packages: HashSet<PackageKey>,
-    available_packages: Vec<Package>,
+    installed: Vec<InstalledPackage>,
+    world_set: HashSet<PackageKey>,
+    available: Vec<Package>,
 }
 
 impl Portage {
     // TODO: Do this differently to allow backgrounded loading
     pub fn new(
-        installed_packages: Vec<InstalledPackage>,
-        world_packages: HashSet<PackageKey>,
-        available_packages: Vec<Package>,
+        installed: Vec<InstalledPackage>,
+        world_set: HashSet<PackageKey>,
+        available: Vec<Package>,
     ) -> Self {
         Self {
-            installed_packages,
-            world_packages,
-            available_packages,
+            installed,
+            world_set,
+            available,
         }
     }
 
     pub fn installed_packages(&self) -> Vec<&InstalledPackage> {
-        self.installed_packages.iter().collect()
+        self.installed.iter().collect()
     }
 
     pub fn world_packages_len(&self) -> usize {
-        self.world_packages.len()
+        self.world_set.len()
     }
 
     pub fn world_packages(&self) -> Vec<&InstalledPackage> {
-        self.installed_packages
+        self.installed
             .iter()
-            .filter(|pkg| self.world_packages.contains(&pkg.atom))
+            .filter(|pkg| self.world_set.contains(&pkg.atom))
             .collect()
     }
 
     pub fn get_installed_package(&self, index: usize) -> Option<&InstalledPackage> {
-        if self.installed_packages.len() > index && index > 0 {
-            return Some(&self.installed_packages[index]);
+        if self.installed.len() > index && index > 0 {
+            return Some(&self.installed[index]);
         }
 
         None
     }
 
     pub fn get_installed_package_key(&self, key: &PackageKey) -> Option<&InstalledPackage> {
-        let pkg = self.installed_packages.iter().find(|pkg| pkg.atom == *key);
+        let pkg = self.installed.iter().find(|pkg| pkg.atom == *key);
         if let Some(pkg) = pkg {
             return Some(pkg);
         }
@@ -59,10 +59,10 @@ impl Portage {
     }
 
     pub fn total_installed_size(&self) -> usize {
-        self.installed_packages.iter().map(|p| p.size).sum()
+        self.installed.iter().map(|p| p.size).sum()
     }
 
     pub(crate) fn installed_packages_len(&self) -> usize {
-        self.installed_packages.len()
+        self.installed.len()
     }
 }
diff --git a/src/gentoo/portage_loader.rs b/src/gentoo/portage_loader.rs
index 792e53d..5e47c23 100644
--- a/src/gentoo/portage_loader.rs
+++ b/src/gentoo/portage_loader.rs
@@ -10,7 +10,7 @@ use quick_xml::{Reader, events::Event};
 
 use crate::gentoo::{
     InstalledPackage, UseFlag,
-    package::{Metadata, Package, PackageKey, Version},
+    package::{Metadata, Package, PackageKey, PackageVersion},
 };
 
 fn split_pkg(input: &str) -> (&str, &str) {
@@ -68,7 +68,7 @@ fn extract_maintainer(path: &Path) -> color_eyre::Result<Option<String>> {
     Ok(None)
 }
 
-fn parse_cache_file(content: String) -> HashMap<String, String> {
+fn parse_cache_file(content: &str) -> HashMap<String, String> {
     content
         .lines()
         .filter_map(|line| {
@@ -137,72 +137,64 @@ pub fn load_available_packages() -> color_eyre::Result<Vec<Package>> {
 
                 let version_file = fs::read_to_string(pkg.path()).wrap_err_with(|| {
                     format!(
-                        "failed to read version_file for {}/{}-{} in repo {}",
-                        cat_name, pkg_name, pkg_version, repo_name
+                        "failed to read version_file for {cat_name}/{pkg_name}-{pkg_version} in repo {repo_name}"
                     )
                 })?;
-                let data = parse_cache_file(version_file);
+                let data = parse_cache_file(&version_file);
 
                 let homepages: Vec<String> = data
                     .get("HOMEPAGE")
-                    .and_then(|s| {
-                        Some(
-                            s.split_whitespace()
-                                .map(std::string::ToString::to_string)
-                                .collect(),
-                        )
+                    .map(|s| {
+                        s.split_whitespace()
+                            .map(std::string::ToString::to_string)
+                            .collect()
                     })
-                    .unwrap_or(vec![]);
+                    .unwrap_or_default();
 
                 let keywords: Vec<String> = data
                     .get("KEYWORDS")
-                    .and_then(|s| {
-                        Some(
-                            s.split_whitespace()
-                                .map(std::string::ToString::to_string)
-                                .collect(),
-                        )
+                    .map(|s| {
+                        s.split_whitespace()
+                            .map(std::string::ToString::to_string)
+                            .collect()
                     })
-                    .unwrap_or(vec![]);
+                    .unwrap_or_default();
 
                 let iuse: Vec<UseFlag> = data
                     .get("IUSE")
-                    .and_then(|s| {
-                        Some(
-                            s.split_whitespace()
-                                .map(|original_iuse| {
-                                    let iuse =
-                                        original_iuse.strip_prefix("+").unwrap_or(original_iuse);
+                    .map(|s| {
+                        s.split_whitespace()
+                            .map(|original_iuse| {
+                                let iuse = original_iuse.strip_prefix("+").unwrap_or(original_iuse);
 
-                                    UseFlag {
-                                        name: iuse.to_string(),
-                                        default: iuse != original_iuse,
-                                    }
-                                })
-                                .collect(),
-                        )
+                                UseFlag {
+                                    name: iuse.to_string(),
+                                    default: iuse != original_iuse,
+                                }
+                            })
+                            .collect()
                     })
-                    .unwrap_or(vec![]);
+                    .unwrap_or_default();
 
                 let repo_path = PathBuf::from("/var/db/repos/")
-                    .join(&repo_name)
+                    .join(repo_name)
                     .join(&cat_name)
                     .join(pkg_name)
                     .join("metadata.xml");
 
                 let maintainer = extract_maintainer(&repo_path).unwrap_or(None);
 
-                let version = Version {
+                let version = PackageVersion {
                     version: pkg_version.to_string(),
                     metadata: Metadata {
-                        maintainer: maintainer,
+                        maintainer,
                         description: data.get("DESCRIPTION").cloned(),
                         homepage: homepages,
                         license: data.get("LICENSE").cloned(),
                         repository: repo_name.to_string(),
                     },
-                    keywords: keywords,
-                    iuse: iuse,
+                    keywords,
+                    iuse,
                 };
 
                 let pkg_key = PackageKey {
@@ -256,7 +248,7 @@ pub fn load_installed_packages() -> color_eyre::Result<Vec<InstalledPackage>> {
             let use_flags_file = fs::read_to_string(pkg.path().join("USE"))?;
             let enabled_use_flags: HashSet<String> = use_flags_file
                 .split_whitespace()
-                .map(|s| s.to_string())
+                .map(ToString::to_string)
                 .collect();
 
             let iuse_flags_file = fs::read_to_string(pkg.path().join("IUSE"))?;
@@ -322,18 +314,18 @@ pub fn load_installed_packages() -> color_eyre::Result<Vec<InstalledPackage>> {
             };
 
             v.push(InstalledPackage {
-                atom: atom,
+                atom,
                 version: pkg_version.to_string(),
                 build_time,
                 slot: 0,
                 metadata: Metadata {
                     maintainer,
                     description,
-                    homepage: homepage,
+                    homepage,
                     license,
-                    repository: repository,
+                    repository,
                 },
-                enabled_use_flags: enabled_use_flags,
+                enabled_use_flags,
                 iuse: use_flags,
                 size,
             });