chore: clippy lint

Author: vladkens

Cargo.lock

@@ -8,14 +8,18 @@ non_camel_case_types = "allow"
 unused_assignments = "allow"
 unreachable_code = "allow"
 
+[lints.clippy]
+single_match = "allow"
+needless_range_loop = "allow"
+
 [profile.release]
 panic = "abort"
 strip = false
 lto = false
 
 [dependencies]
 chrono = "0.4.39"
-clap = { version = "4.5.30", features = ["derive"] }
+clap = { version = "4.5.31", features = ["derive"] }
 core-foundation = "0.10.0"
 libc = "0.2.170"
 num-traits = "0.2.19"

Cargo.toml

@@ -1,5 +1,6 @@
 lint:
 	cargo fmt --check
+	cargo clippy --all-targets --all-features -- -D warnings
 	cargo check --release --locked
 
 build:

Makefile

@@ -31,8 +31,7 @@ fn enter_term() -> Terminal<impl Backend> {
   stdout().execute(terminal::EnterAlternateScreen).unwrap();
 
   let term = CrosstermBackend::new(std::io::stdout());
-  let term = Terminal::new(term).unwrap();
-  term
+  Terminal::new(term).unwrap()
 }
 
 fn leave_term() {
@@ -218,7 +217,7 @@ fn run_sampler_thread(tx: mpsc::Sender<Event>, msec: Arc<RwLock<u32>>) {
 // get average of two values, used to smooth out metrics
 // see: https://github.com/vladkens/macmon/issues/10
 fn avg2<T: num_traits::Float>(a: T, b: T) -> T {
-  return if a == T::zero() { b } else { (a + b) / T::from(2.0).unwrap() };
+  if a == T::zero() { b } else { (a + b) / T::from(2.0).unwrap() }
 }
 
 // MARK: App
@@ -275,11 +274,11 @@ impl App {
       // .title_style(Style::default().gray())
       .padding(Padding::ZERO);
 
-    if label_l.len() > 0 {
+    if !label_l.is_empty() {
       block = block.title_top(Line::from(format!(" {label_l} ")));
     }
 
-    if label_r.len() > 0 {
+    if !label_r.is_empty() {
       block = block.title_top(Line::from(format!(" {label_r} ")).alignment(Alignment::Right));
     }
 
@@ -434,7 +433,7 @@ impl App {
 
   pub fn run_loop(&mut self, interval: Option<u32>) -> WithError<()> {
     // use from arg if provided, otherwise use config restored value
-    self.cfg.interval = interval.unwrap_or(self.cfg.interval).max(100).min(10_000);
+    self.cfg.interval = interval.unwrap_or(self.cfg.interval).clamp(100, 10_000);
     let msec = Arc::new(RwLock::new(self.cfg.interval));
 
     let (tx, rx) = mpsc::channel::<Event>();

src/app.rs

@@ -50,10 +50,7 @@ impl Config {
       };
 
       let reader = std::io::BufReader::new(file);
-      return match serde_json::from_reader(reader) {
-        Ok(config) => config,
-        Err(_) => Self::default(),
-      };
+      return serde_json::from_reader(reader).unwrap_or_default();
     }
 
     Self::default()
@@ -89,7 +86,7 @@ impl Config {
 
   pub fn dec_interval(&mut self) {
     let step = 250;
-    self.interval = ((self.interval.saturating_sub(step) + step - 1) / step * step).max(step);
+    self.interval = (self.interval.saturating_sub(step).div_ceil(step) * step).max(step);
     self.save();
   }
 

src/config.rs

@@ -8,7 +8,7 @@ use crate::sources::{
 type WithError<T> = Result<T, Box<dyn std::error::Error>>;
 
 fn print_divider(msg: &str) {
-  if msg.len() == 0 {
+  if msg.is_empty() {
     println!("{}", "-".repeat(80));
     return;
   }
@@ -88,12 +88,12 @@ pub fn print_debug() -> WithError<()> {
       continue;
     }
 
-    let ki = smc.read_key_info(&key)?;
+    let ki = smc.read_key_info(key)?;
     if !(ki.data_type == FLOAT_TYPE && ki.data_size == 4) {
       continue;
     }
 
-    let val = smc.read_val(&key);
+    let val = smc.read_val(key);
     if val.is_err() {
       continue;
     }
@@ -107,7 +107,7 @@ pub fn print_debug() -> WithError<()> {
     print!("{}={:04.1}  ", key, val);
   }
 
-  println!(""); // close previous line
+  println!(); // close previous line
 
   print_divider("IOHID");
   let hid = IOHIDSensors::new()?;

src/debug.rs

@@ -47,10 +47,10 @@ pub struct Metrics {
 
 pub fn zero_div<T: core::ops::Div<Output = T> + Default + PartialEq>(a: T, b: T) -> T {
   let zero: T = Default::default();
-  return if b == zero { zero } else { a / b };
+  if b == zero { zero } else { a / b }
 }
 
-fn calc_freq(item: CFDictionaryRef, freqs: &Vec<u32>) -> (u32, f32) {
+fn calc_freq(item: CFDictionaryRef, freqs: &[u32]) -> (u32, f32) {
   let items = cfio_get_residencies(item); // (ns, freq)
   let (len1, len2) = (items.len(), freqs.len());
   assert!(len1 > len2, "cacl_freq invalid data: {} vs {}", len1, len2); // todo?
@@ -69,17 +69,17 @@ fn calc_freq(item: CFDictionaryRef, freqs: &Vec<u32>) -> (u32, f32) {
   }
 
   let usage_ratio = zero_div(usage, total);
-  let min_freq = freqs.first().unwrap().clone() as f64;
-  let max_freq = freqs.last().unwrap().clone() as f64;
+  let min_freq = *freqs.first().unwrap() as f64;
+  let max_freq = *freqs.last().unwrap() as f64;
   let from_max = (avg_freq.max(min_freq) * usage_ratio) / max_freq;
 
   (avg_freq as u32, from_max as f32)
 }
 
-fn calc_freq_final(items: &Vec<(u32, f32)>, freqs: &Vec<u32>) -> (u32, f32) {
+fn calc_freq_final(items: &[(u32, f32)], freqs: &[u32]) -> (u32, f32) {
   let avg_freq = zero_div(items.iter().map(|x| x.0 as f32).sum(), items.len() as f32);
-  let avg_perc = zero_div(items.iter().map(|x| x.1 as f32).sum(), items.len() as f32);
-  let min_freq = freqs.first().unwrap().clone() as f32;
+  let avg_perc = zero_div(items.iter().map(|x| x.1).sum(), items.len() as f32);
+  let min_freq = *freqs.first().unwrap() as f32;
 
   (avg_freq.max(min_freq) as u32, avg_perc)
 }
@@ -93,7 +93,7 @@ fn init_smc() -> WithError<(SMC, Vec<String>, Vec<String>)> {
 
   let names = smc.read_all_keys().unwrap_or(vec![]);
   for name in &names {
-    let key = match smc.read_key_info(&name) {
+    let key = match smc.read_key_info(name) {
       Ok(key) => key,
       Err(_) => continue,
     };
@@ -102,7 +102,7 @@ fn init_smc() -> WithError<(SMC, Vec<String>, Vec<String>)> {
       continue;
     }
 
-    let _ = match smc.read_val(&name) {
+    let _ = match smc.read_val(name) {
       Ok(val) => val,
       Err(_) => continue,
     };
@@ -204,7 +204,7 @@ impl Sampler {
   fn get_temp(&mut self) -> WithError<TempMetrics> {
     // HID for M1, SMC for M2/M3
     // UPD: Looks like HID/SMC related to OS version, not to the chip (SMC available from macOS 14)
-    match self.smc_cpu_keys.len() > 0 {
+    match !self.smc_cpu_keys.is_empty() {
       true => self.get_temp_smc(),
       false => self.get_temp_hid(),
     }
@@ -248,7 +248,7 @@ impl Sampler {
 
         if x.group == "GPU Stats" && x.subgroup == GPU_FREQ_DICE_SUBG {
           match x.channel.as_str() {
-            "GPUPH" => rs.gpu_usage = calc_freq(x.item, &self.soc.gpu_freqs[1..].to_vec()),
+            "GPUPH" => rs.gpu_usage = calc_freq(x.item, &self.soc.gpu_freqs[1..]),
             _ => {}
           }
         }

src/metrics.rs

@@ -325,15 +325,13 @@ pub fn libc_ram() -> WithError<(u64, u64)> {
 
     let page_size_kb = libc::sysconf(libc::_SC_PAGESIZE) as u64;
 
-    usage = (0
-      + stats.active_count as u64
+    usage = (stats.active_count as u64
       + stats.inactive_count as u64
       + stats.wire_count as u64
       + stats.speculative_count as u64
       + stats.compressor_page_count as u64
       - stats.purgeable_count as u64
-      - stats.external_page_count as u64
-      + 0)
+      - stats.external_page_count as u64)
       * page_size_kb;
   }
 
@@ -412,7 +410,7 @@ pub fn get_dvfs_mhz(dict: CFDictionaryRef, key: &str) -> (Vec<u32>, Vec<u32>) {
 pub fn run_system_profiler() -> WithError<serde_json::Value> {
   // system_profiler -listDataTypes
   let out = std::process::Command::new("system_profiler")
-    .args(&["SPHardwareDataType", "SPDisplaysDataType", "SPSoftwareDataType", "-json"])
+    .args(["SPHardwareDataType", "SPDisplaysDataType", "SPSoftwareDataType", "-json"])
     .output()?;
 
   let out = std::str::from_utf8(&out.stdout)?;
@@ -500,7 +498,7 @@ pub fn get_soc_info() -> WithError<SocInfo> {
 
 fn cfio_get_chan(items: Vec<(&str, Option<&str>)>) -> WithError<CFMutableDictionaryRef> {
   // if no items are provided, return all channels
-  if items.len() == 0 {
+  if items.is_empty() {
     unsafe {
       let c = IOReportCopyAllChannels(0, 0);
       let r = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, CFDictionaryGetCount(c), c);
@@ -512,7 +510,7 @@ fn cfio_get_chan(items: Vec<(&str, Option<&str>)>) -> WithError<CFMutableDiction
   let mut channels = vec![];
   for (group, subgroup) in items {
     let gname = cfstr(group);
-    let sname = subgroup.map_or(null(), |x| cfstr(x));
+    let sname = subgroup.map_or(null(), cfstr);
     let chan = unsafe { IOReportCopyChannelsInGroup(gname, sname, 0, 0, 0) };
     channels.push(chan);
 
@@ -583,7 +581,7 @@ impl IOReport {
   }
 
   pub fn get_samples(&mut self, duration: u64, count: usize) -> Vec<(IOReportIterator, u64)> {
-    let count = count.max(1).min(32);
+    let count = count.clamp(1, 32);
     let mut samples: Vec<(IOReportIterator, u64)> = Vec::with_capacity(count);
     let step_msec = duration / count as u64;
 
@@ -663,8 +661,8 @@ pub struct IOHIDSensors {
 
 impl IOHIDSensors {
   pub fn new() -> WithError<Self> {
-    let keys = vec![cfstr("PrimaryUsagePage"), cfstr("PrimaryUsage")];
-    let nums = vec![cfnum(kHIDPage_AppleVendor), cfnum(kHIDUsage_AppleVendor_TemperatureSensor)];
+    let keys = [cfstr("PrimaryUsagePage"), cfstr("PrimaryUsage")];
+    let nums = [cfnum(kHIDPage_AppleVendor), cfnum(kHIDUsage_AppleVendor_TemperatureSensor)];
 
     let dict = unsafe {
       CFDictionaryCreate(
@@ -799,6 +797,7 @@ pub struct SensorVal {
 
 // MARK: SMC
 
+#[allow(clippy::upper_case_acronyms)]
 pub struct SMC {
   conn: u32,
   keys: HashMap<u32, KeyInfo>,
@@ -861,7 +860,7 @@ impl SMC {
     let key = key.bytes().fold(0, |acc, x| (acc << 8) + x as u32);
     if let Some(ki) = self.keys.get(&key) {
       // println!("cache hit for {}", key);
-      return Ok(ki.clone());
+      return Ok(*ki);
     }
 
     let ival = KeyData { data8: 9, key, ..Default::default() };