refactor: use clippy::unwrap_used (#1882)

* refactor: use clippy::unwrap_used

* fix log format use

* fix a bunch of macos ones

* oop

* allow schema script

* driveby schema bump

Author: ClementTsang

Cargo.toml

@@ -254,3 +254,4 @@ missing_crate_level_docs = "deny"
 todo = "deny"
 unimplemented = "deny"
 missing_safety_doc = "deny"
+unwrap_used = "deny"

build.rs

@@ -1,5 +1,7 @@
 //! General build script used by bottom to generate completion files and set binary version.
 
+#![expect(clippy::unwrap_used)]
+
 #[expect(dead_code)]
 #[path = "src/options/args.rs"]
 mod args;

clippy.toml

@@ -1,3 +1,5 @@
 cognitive-complexity-threshold = 100
 type-complexity-threshold = 500
 too-many-arguments-threshold = 8
+allow-unwrap-in-consts = true
+allow-unwrap-in-tests = true

schema/nightly/bottom.json

@@ -471,6 +471,12 @@
             }
           ]
         },
+        "read_only": {
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
         "regex": {
           "type": [
             "boolean",

src/app/data/store.rs

@@ -213,7 +213,7 @@ impl StoredData {
                         reason = "this is fine since it's done via a static OnceLock. In the future though, separate it out."
                     )]
                     if let Some(new_name) = DISK_REGEX
-                        .get_or_init(|| Regex::new(r"disk\d+").unwrap())
+                        .get_or_init(|| Regex::new(r"disk\d+").expect("valid regex"))
                         .find(checked_name)
                     {
                         io.get(new_name.as_str())

src/app/states.rs

@@ -192,7 +192,7 @@ impl AppSearchState {
 
                     self.grapheme_cursor
                         .next_boundary(chunk, start_position)
-                        .unwrap();
+                        .expect("another grapheme boundary should exist after the cursor with the provided context");
                 }
                 _ => panic!("{err:?}"),
             },
@@ -213,7 +213,9 @@ impl AppSearchState {
                     self.grapheme_cursor
                         .provide_context(&self.current_search_query[0..ctx], 0);
 
-                    self.grapheme_cursor.prev_boundary(chunk, 0).unwrap();
+                    self.grapheme_cursor
+                        .prev_boundary(chunk, 0)
+                        .expect("another grapheme boundary should exist before the cursor with the provided context");
                 }
                 _ => panic!("{err:?}"),
             },

src/bin/schema.rs

@@ -1,4 +1,8 @@
 #![cfg(feature = "generate_schema")]
+#![expect(
+    clippy::unwrap_used,
+    reason = "this is just used to generate jsonschema files"
+)]
 
 use bottom::{options::config, widgets};
 use clap::Parser;

src/canvas/components/time_graph/base/time_chart.rs

@@ -674,17 +674,22 @@ impl<'a> TimeChart<'a> {
         &self, buf: &mut Buffer, layout: &ChartLayout, chart_area: Rect, graph_area: Rect,
     ) {
         let Some(y) = layout.label_x else { return };
-        let labels = self.x_axis.labels.as_ref().unwrap();
+        let Some(labels) = self.x_axis.labels.as_ref() else {
+            return;
+        };
         let labels_len = labels.len() as u16;
         if labels_len < 2 {
             return;
         }
 
+        let first_label = labels.first().expect("must have at least 2 labels");
+        let last_label = labels.last().expect("must have at least 2 labels");
+
         let width_between_ticks = graph_area.width / labels_len;
 
         let label_area = self.first_x_label_area(
             y,
-            labels.first().unwrap().width() as u16,
+            first_label.width() as u16,
             width_between_ticks,
             chart_area,
             graph_area,
@@ -696,7 +701,7 @@ impl<'a> TimeChart<'a> {
             Alignment::Right => Alignment::Left,
         };
 
-        Self::render_label(buf, labels.first().unwrap(), label_area, label_alignment);
+        Self::render_label(buf, first_label, label_area, label_alignment);
 
         for (i, label) in labels[1..labels.len() - 1].iter().enumerate() {
             // We add 1 to x (and width-1 below) to leave at least one space before each
@@ -710,7 +715,7 @@ impl<'a> TimeChart<'a> {
         let x = graph_area.right() - width_between_ticks;
         let label_area = Rect::new(x, y, width_between_ticks, 1);
         // The last label should be aligned Right to be at the edge of the graph area
-        Self::render_label(buf, labels.last().unwrap(), label_area, Alignment::Right);
+        Self::render_label(buf, last_label, label_area, Alignment::Right);
     }
 
     fn first_x_label_area(
@@ -751,8 +756,11 @@ impl<'a> TimeChart<'a> {
         // FIXME: Control how many y-axis labels are rendered based on height.
 
         let Some(x) = layout.label_y else { return };
-        let labels = self.y_axis.labels.as_ref().unwrap();
+        let Some(labels) = self.y_axis.labels.as_ref() else {
+            return;
+        };
         let labels_len = labels.len() as u16;
+
         for (i, label) in labels.iter().enumerate() {
             let dy = i as u16 * (graph_area.height - 1) / (labels_len - 1);
             if dy < graph_area.bottom() {
@@ -836,39 +844,41 @@ impl Widget for TimeChart<'_> {
             .render(graph_area, buf);
 
         if let Some((x, y)) = layout.title_x {
-            let title = self.x_axis.title.as_ref().unwrap();
-            let width = graph_area
-                .right()
-                .saturating_sub(x)
-                .min(title.width() as u16);
-            buf.set_style(
-                Rect {
-                    x,
-                    y,
-                    width,
-                    height: 1,
-                },
-                original_style,
-            );
-            buf.set_line(x, y, title, width);
+            if let Some(title) = self.x_axis.title.as_ref() {
+                let width = graph_area
+                    .right()
+                    .saturating_sub(x)
+                    .min(title.width() as u16);
+                buf.set_style(
+                    Rect {
+                        x,
+                        y,
+                        width,
+                        height: 1,
+                    },
+                    original_style,
+                );
+                buf.set_line(x, y, title, width);
+            }
         }
 
         if let Some((x, y)) = layout.title_y {
-            let title = self.y_axis.title.as_ref().unwrap();
-            let width = graph_area
-                .right()
-                .saturating_sub(x)
-                .min(title.width() as u16);
-            buf.set_style(
-                Rect {
-                    x,
-                    y,
-                    width,
-                    height: 1,
-                },
-                original_style,
-            );
-            buf.set_line(x, y, title, width);
+            if let Some(title) = self.y_axis.title.as_ref() {
+                let width = graph_area
+                    .right()
+                    .saturating_sub(x)
+                    .min(title.width() as u16);
+                buf.set_style(
+                    Rect {
+                        x,
+                        y,
+                        width,
+                        height: 1,
+                    },
+                    original_style,
+                );
+                buf.set_line(x, y, title, width);
+            }
         }
 
         if let Some(legend_area) = layout.legend_area {

src/canvas/components/time_graph/base/time_chart/grid.rs

@@ -75,7 +75,7 @@ impl Grid for BrailleGrid {
     }
 
     fn save(&self) -> Layer {
-        let string = String::from_utf16(&self.utf16_code_points).unwrap();
+        let string = String::from_utf16(&self.utf16_code_points).expect("valid UTF-16 data");
         // the background color is always reset for braille patterns
         let colors = self.colors.iter().map(|c| (*c, Color::Reset)).collect();
         Layer { string, colors }

src/canvas/components/widget_carousel.rs

@@ -18,8 +18,8 @@ impl Painter {
             let current_table = if let BottomWidgetType::ProcSort = current_table.widget_type {
                 current_table
                     .right_neighbour
-                    .map(|id| app_state.widget_map.get(&id).unwrap())
-                    .unwrap()
+                    .and_then(|id| app_state.widget_map.get(&id))
+                    .expect("id must exist in widget mapping")
             } else {
                 current_table
             };