Clippy pedantic changes

6 files changed, 117 insertions, 124 deletions

diff --git a/src/app.rs b/src/app.rs
index 7c5018d..8e0de7f 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -22,7 +22,7 @@ pub struct App<'a> {
     pub view: ViewState,
 }
 
-impl<'a> App<'a> {
+impl App<'_> {
     pub fn new(portage: Portage) -> Self {
         App {
             portage,
@@ -46,11 +46,7 @@ impl<'a> App<'a> {
     }
 
     pub fn current_package(&self) -> &Package {
-        let selected_package_index = match self.list_state.selected() {
-            Some(selected) => selected,
-            None => 0,
-        };
-
+        let selected_package_index = self.list_state.selected().unwrap_or_default();
         &self.portage.installed_packages[selected_package_index]
     }
 
@@ -96,18 +92,16 @@ impl<'a> App<'a> {
 
         self.search_indexes = None;
 
-        return false;
+        false
     }
 
     pub fn next_search(&mut self) {
-        let mut current_index = match self.current_search_index {
-            Some(i) => i,
-            None => return,
+        let Some(mut current_index) = self.current_search_index else {
+            return;
         };
 
-        let search_indexes = match &self.search_indexes {
-            Some(i) => i,
-            None => return,
+        let Some(search_indexes) = &self.search_indexes else {
+            return;
         };
 
         if current_index + 1 >= search_indexes.len() {
@@ -119,18 +113,16 @@ impl<'a> App<'a> {
         let list_index = search_indexes[current_index];
 
         self.list_state.select(Some(list_index));
-        self.current_search_index = Some(current_index)
+        self.current_search_index = Some(current_index);
     }
 
     pub fn prev_search(&mut self) {
-        let mut current_index = match self.current_search_index {
-            Some(i) => i,
-            None => return,
+        let Some(mut current_index) = self.current_search_index else {
+            return;
         };
 
-        let search_indexes = match &self.search_indexes {
-            Some(i) => i,
-            None => return,
+        let Some(search_indexes) = &self.search_indexes else {
+            return;
         };
 
         if current_index == 0 {
@@ -142,6 +134,6 @@ impl<'a> App<'a> {
         let list_index = search_indexes[current_index];
 
         self.list_state.select(Some(list_index));
-        self.current_search_index = Some(current_index)
+        self.current_search_index = Some(current_index);
     }
 }
diff --git a/src/event.rs b/src/event.rs
index b3a0e8f..81cf6bd 100644
--- a/src/event.rs
+++ b/src/event.rs
@@ -15,10 +15,8 @@ pub fn handle_event(app: &mut App) -> io::Result<bool> {
             crate::app::ViewState::InstalledPackages => {
                 if app.showing_search_window {
                     handle_search_keybinds(key, app);
-                } else {
-                    if handle_installed_packages_keybinds(key, app) {
-                        return Ok(true);
-                    }
+                } else if handle_installed_packages_keybinds(key, app) {
+                    return Ok(true);
                 }
             }
         }
@@ -33,12 +31,10 @@ fn handle_search_keybinds(key: KeyEvent, app: &mut App) {
         KeyCode::Enter => {
             app.search();
             app.toggle_search_window();
-            ()
         }
         _ => {
             app.textarea.input_without_shortcuts(key);
             app.search_found = Some(app.search());
-            ()
         }
     }
 }
@@ -54,7 +50,7 @@ fn handle_installed_packages_keybinds(key: KeyEvent, app: &mut App) -> bool {
                     if selected < 30 {
                         app.list_state.select(Some(0));
                     } else {
-                        app.list_state.select(Some(selected - 30))
+                        app.list_state.select(Some(selected - 30));
                     }
                 }
             }
@@ -85,5 +81,5 @@ fn handle_dashboard_keybinds(key: KeyEvent, app: &mut App) -> bool {
         _ => {}
     }
 
-    return false;
+    false
 }
diff --git a/src/gentoo/package.rs b/src/gentoo/package.rs
index d23b40b..a74a09c 100644
--- a/src/gentoo/package.rs
+++ b/src/gentoo/package.rs
@@ -1,10 +1,12 @@
+use std::collections::HashSet;
+
 use crate::gentoo::UseFlag;
 
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub struct Package {
     pub name: String,
-    pub use_flags: Vec<UseFlag>,
+    pub use_flags: HashSet<UseFlag>,
     pub version: String,
     pub repository: String,
     pub maintainer: Option<String>,
@@ -14,29 +16,29 @@ pub struct Package {
     pub size: usize,
 }
 
-#[allow(dead_code)]
-impl Package {
-    pub fn new(
-        name: String,
-        version: String,
-        repository: String,
-        size: usize,
-        homepage: Option<Vec<String>>,
-        license: Option<String>,
-        description: Option<String>,
-        maintainer: Option<String>,
-        use_flags: Vec<UseFlag>,
-    ) -> Self {
-        Package {
-            name,
-            use_flags,
-            version,
-            repository,
-            maintainer,
-            description,
-            homepage,
-            license,
-            size,
-        }
-    }
-}
+// #[allow(dead_code)]
+// impl Package {
+//     pub fn new(
+//         name: String,
+//         version: String,
+//         repository: String,
+//         size: usize,
+//         homepage: Option<Vec<String>>,
+//         license: Option<String>,
+//         description: Option<String>,
+//         maintainer: Option<String>,
+//         use_flags: HashSet<UseFlag>,
+//     ) -> Self {
+//         Package {
+//             name,
+//             use_flags,
+//             version,
+//             repository,
+//             maintainer,
+//             description,
+//             homepage,
+//             license,
+//             size,
+//         }
+//     }
+// }
diff --git a/src/gentoo/portage.rs b/src/gentoo/portage.rs
index ad473b1..bc9bb32 100644
--- a/src/gentoo/portage.rs
+++ b/src/gentoo/portage.rs
@@ -1,4 +1,8 @@
-use std::{fs, io, path::PathBuf};
+use std::{
+    collections::HashSet,
+    fs, io,
+    path::{Path, PathBuf},
+};
 
 use quick_xml::{Reader, events::Event};
 
@@ -14,21 +18,20 @@ fn split_pkg(input: &str) -> (&str, Option<&str>) {
     let bytes = input.as_bytes();
 
     for i in (0..bytes.len()).rev() {
-        if bytes[i] == b'-' {
-            if let Some(next) = bytes.get(i + 1) {
-                if next.is_ascii_digit() {
-                    let name = &input[..i];
-                    let version = &input[i + 1..];
-                    return (name, Some(version));
-                }
-            }
+        if bytes[i] == b'-'
+            && let Some(next) = bytes.get(i + 1)
+            && next.is_ascii_digit()
+        {
+            let name = &input[..i];
+            let version = &input[i + 1..];
+            return (name, Some(version));
         }
     }
 
     (input, None)
 }
 
-fn extract_maintainer(path: &PathBuf) -> io::Result<Option<String>> {
+fn extract_maintainer(path: &Path) -> io::Result<Option<String>> {
     let s = fs::read_to_string(path)?;
     let mut reader = Reader::from_str(s.as_str());
     reader.config_mut().trim_text(true);
@@ -55,8 +58,7 @@ fn extract_maintainer(path: &PathBuf) -> io::Result<Option<String>> {
                 in_maintainer = false;
             }
 
-            Ok(Event::Eof) => break,
-            Err(_) => break,
+            Ok(Event::Eof) | Err(_) => break,
 
             _ => {}
         }
@@ -77,7 +79,10 @@ impl Portage {
 
     pub fn load_world_packages(&mut self) -> io::Result<()> {
         let world = fs::read_to_string("/var/lib/portage/world")?;
-        self.world_packages = world.split_whitespace().map(|s| s.to_string()).collect();
+        self.world_packages = world
+            .split_whitespace()
+            .map(std::string::ToString::to_string)
+            .collect();
         Ok(())
     }
 
@@ -85,42 +90,31 @@ impl Portage {
         let categories = fs::read_dir("/var/db/pkg")?;
 
         for category in categories {
-            let category = match category {
-                Ok(c) => c,
-                Err(_) => continue,
+            let Ok(category) = category else {
+                continue;
             };
 
             let cat_name = category.file_name();
             let pkgs = fs::read_dir(category.path())?;
             for pkg in pkgs {
-                let pkg = match pkg {
-                    Ok(p) => p,
-                    Err(_) => continue,
+                let Ok(pkg) = pkg else {
+                    continue;
                 };
 
                 let pkg_name = pkg.file_name();
-                let pkg_name = match pkg_name.to_str() {
-                    Some(n) => n,
-                    None => continue,
+                let Some(pkg_name) = pkg_name.to_str() else {
+                    continue;
                 };
 
                 let (pkg_name, pkg_version) = split_pkg(pkg_name);
 
-                let use_flags_file = fs::read(pkg.path().join("USE"))?;
-                let use_flags: Vec<&str> = str::from_utf8(&use_flags_file)
-                    .unwrap_or_default()
-                    .trim()
-                    .split(' ')
-                    .collect();
+                let use_flags_file = fs::read_to_string(pkg.path().join("USE"))?;
+                let use_flags: HashSet<&str> = use_flags_file.trim().split(' ').collect();
 
-                let iuse_flags_file = fs::read(pkg.path().join("IUSE"))?;
-                let iuse_flags: Vec<&str> = str::from_utf8(&iuse_flags_file)
-                    .unwrap_or_default()
-                    .trim()
-                    .split(' ')
-                    .collect();
+                let iuse_flags_file = fs::read_to_string(pkg.path().join("IUSE"))?;
+                let iuse_flags: Vec<&str> = iuse_flags_file.trim().split(' ').collect();
 
-                let use_flags: Vec<UseFlag> = iuse_flags
+                let use_flags: HashSet<UseFlag> = iuse_flags
                     .iter()
                     .filter(|x| !x.trim().is_empty())
                     .map(|&original_iuse| {
@@ -138,9 +132,12 @@ impl Portage {
                     .to_string();
                 let homepage: Option<Vec<String>> =
                     match fs::read_to_string(pkg.path().join("HOMEPAGE")) {
-                        Ok(homepage) => {
-                            Some(homepage.split_whitespace().map(|s| s.to_string()).collect())
-                        }
+                        Ok(homepage) => Some(
+                            homepage
+                                .split_whitespace()
+                                .map(std::string::ToString::to_string)
+                                .collect(),
+                        ),
                         Err(_) => None,
                     };
 
@@ -168,17 +165,17 @@ impl Portage {
 
                 let maintainer = extract_maintainer(&repo_path)?;
 
-                self.installed_packages.push(Package::new(
-                    format!("{}/{}", cat_name.to_str().unwrap_or_default(), pkg_name),
-                    pkg_version.unwrap().into(),
+                self.installed_packages.push(Package {
+                    name: format!("{}/{}", cat_name.to_str().unwrap_or_default(), pkg_name),
+                    use_flags,
+                    version: pkg_version.unwrap_or_default().into(),
                     repository,
-                    size,
+                    maintainer,
+                    description,
                     homepage,
                     license,
-                    description,
-                    maintainer,
-                    use_flags,
-                ));
+                    size,
+                });
             }
         }
 
diff --git a/src/gentoo/useflags.rs b/src/gentoo/useflags.rs
index 0b7d981..1e83b32 100644
--- a/src/gentoo/useflags.rs
+++ b/src/gentoo/useflags.rs
@@ -1,4 +1,4 @@
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct UseFlag {
     pub name: String,
     pub enabled: bool,
diff --git a/src/ui.rs b/src/ui.rs
index 32e10fd..5348bfb 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -1,3 +1,5 @@
+use std::fmt::Write as _;
+
 use ratatui::{
     Frame,
     layout::{Alignment, Constraint, Direction, Layout, Spacing},
@@ -16,7 +18,7 @@ pub fn ui(frame: &mut Frame, app: &mut App) {
     }
 }
 
-fn render_dashboard(frame: &mut Frame, app: &mut App) {
+fn render_dashboard(frame: &mut Frame, app: &App) {
     let logo = "
  ██████╗ ██╗   ██╗██╗███████╗██╗    ██╗
 ██╔═══██╗██║   ██║██║██╔════╝██║    ██║
@@ -153,21 +155,20 @@ fn render_installed_packages(frame: &mut Frame, app: &mut App) {
     render_use_flags(frame, split_vert[0], app);
     render_package_metadata(frame, split_vert[1], app);
 
-    let text = match app.showing_search_window {
-        false => {
-            let mut main_key_hint = "(q) to quit | (j) down | (k) up | (/) to search".to_string();
-            if let (Some(current), Some(total)) = (app.current_search_index, app.search_indexes_len)
-            {
-                main_key_hint.push_str(&format!(
-                    " | (n) for next search | (N) for previous search | Searches found: {} / {}",
-                    current + 1,
-                    total
-                ));
-            }
-
-            main_key_hint
+    let text = if app.showing_search_window {
+        "(esc) to quit search | (enter) to search".to_string()
+    } else {
+        let mut main_key_hint = "(q) to quit | (j) down | (k) up | (/) to search".to_string();
+        if let (Some(current), Some(total)) = (app.current_search_index, app.search_indexes_len) {
+            let _ = write!(
+                main_key_hint,
+                " | (n) for next search | (N) for previous search | Searches found: {} / {}",
+                current + 1,
+                total
+            );
         }
-        true => "(esc) to quit search | (enter) to search".to_string(),
+
+        main_key_hint
     };
 
     let key_hint = Span::styled(text, Style::default().fg(Color::Yellow));
@@ -184,9 +185,9 @@ fn render_installed_packages(frame: &mut Frame, app: &mut App) {
 
         if let Some(found) = app.search_found {
             if found {
-                popup_block = popup_block.border_style(Style::default().fg(Color::Green))
+                popup_block = popup_block.border_style(Style::default().fg(Color::Green));
             } else {
-                popup_block = popup_block.border_style(Style::default().fg(Color::Red))
+                popup_block = popup_block.border_style(Style::default().fg(Color::Red));
             }
         }
 
@@ -200,7 +201,7 @@ fn render_installed_packages(frame: &mut Frame, app: &mut App) {
     }
 }
 
-fn render_package_metadata(frame: &mut Frame, area: Rect, app: &mut App) {
+fn render_package_metadata(frame: &mut Frame, area: Rect, app: &App) {
     let pkg = app.current_package();
 
     let bold_style = Style::default().add_modifier(Modifier::BOLD);
@@ -236,7 +237,7 @@ fn render_package_metadata(frame: &mut Frame, area: Rect, app: &mut App) {
 
     let mut lines = vec![maintainer, version, repository, license, description, size];
 
-    let mut homepage = homepage_lines(&pkg, bold_style);
+    let mut homepage = homepage_lines(pkg, bold_style);
     lines.append(&mut homepage);
 
     let paragraph = Paragraph::new(lines)
@@ -294,7 +295,12 @@ fn search_popup_rect(percent_x: u16, r: Rect) -> Rect {
 }
 
 fn render_packages(frame: &mut Frame, area: Rect, app: &mut App) {
-    let items = app.installed_packages().into_iter().map(|x| x.name.clone());
+    let items: Vec<String> = app
+        .installed_packages()
+        .iter()
+        .map(|x| x.name.clone())
+        .collect();
+
     let list = List::new(items)
         .style(Color::White)
         .highlight_style(Modifier::REVERSED)
@@ -308,7 +314,7 @@ fn render_packages(frame: &mut Frame, area: Rect, app: &mut App) {
     frame.render_stateful_widget(list, area, &mut app.list_state);
 }
 
-fn render_use_flags(frame: &mut Frame, area: Rect, app: &mut App) {
+fn render_use_flags(frame: &mut Frame, area: Rect, app: &App) {
     let selected_package = app.current_package();
 
     let items = selected_package.use_flags.iter().map(|x| {