treewide: fix inconsistent logslop

Author: RGBCube

watt/config.rs

@@ -734,8 +734,7 @@ impl Expression {
         Boolean(available)
       },
       IsDriverLoaded { value } => {
-        let value = eval!(value);
-        let value = value.try_into_string()?;
+        let value = eval!(value).try_into_string()?;
 
         Boolean(crate::fs::exists(format!("/sys/module/{value}")))
       },
@@ -991,7 +990,7 @@ impl DaemonConfig {
 
     config.rules.sort_by_key(|rule| rule.priority);
 
-    log::debug!("sorted {} rules by priority", config.rules.len());
+    log::debug!("sorted {len} rules by priority", len = config.rules.len());
 
     log::debug!("loaded config: {config:#?}");
 

watt/cpu.rs

@@ -156,14 +156,14 @@ impl Cpu {
       }
     }
 
-    log::info!("detected {} CPUs", cpus.len());
+    log::info!("detected {len} CPUs", len = cpus.len());
 
     Ok(cpus)
   }
 
   /// Scan CPU, tuning local copy of settings.
   fn scan(&mut self, cache: &CpuScanCache) -> anyhow::Result<()> {
-    log::debug!("scanning CPU {}", self.number);
+    log::debug!("scanning CPU {number}", number = self.number);
 
     let Self { number, .. } = self;
 
@@ -174,7 +174,7 @@ impl Cpu {
     self.has_cpufreq =
       fs::exists(format!("/sys/devices/system/cpu/cpu{number}/cpufreq"));
 
-    log::trace!("CPU {} has cpufreq: {}", self.number, self.has_cpufreq);
+    log::trace!("CPU {number} has cpufreq: {has_cpufreq}", number = self.number, has_cpufreq = self.has_cpufreq);
 
     if self.has_cpufreq {
       self.scan_governor()?;
@@ -190,7 +190,7 @@ impl Cpu {
   }
 
   fn scan_governor(&mut self) -> anyhow::Result<()> {
-    log::trace!("scanning governor for CPU {}", self.number);
+    log::trace!("scanning governor for CPU {number}", number = self.number);
 
     let Self { number, .. } = *self;
 
@@ -223,7 +223,7 @@ impl Cpu {
   }
 
   fn scan_frequency(&mut self) -> anyhow::Result<()> {
-    log::trace!("scanning frequency for CPU {}", self.number);
+    log::trace!("scanning frequency for CPU {number}", number = self.number);
 
     let Self { number, .. } = *self;
 
@@ -248,7 +248,7 @@ impl Cpu {
   }
 
   fn scan_epp(&mut self) -> anyhow::Result<()> {
-    log::trace!("scanning EPP for CPU {}", self.number);
+    log::trace!("scanning EPP for CPU {number}", number = self.number);
 
     let Self { number, .. } = *self;
 
@@ -280,7 +280,7 @@ impl Cpu {
   }
 
   fn scan_epb(&mut self) -> anyhow::Result<()> {
-    log::trace!("scanning EPB for CPU {}", self.number);
+    log::trace!("scanning EPB for CPU {number}", number = self.number);
 
     let Self { number, .. } = self;
 
@@ -319,7 +319,7 @@ impl Cpu {
   }
 
   fn scan_stat(&mut self, cache: &CpuScanCache) -> anyhow::Result<()> {
-    log::trace!("scanning stat for CPU {}", self.number);
+    log::trace!("scanning stat for CPU {number}", number = self.number);
 
     // OnceCell::get_or_try_init is unstable. Cope:
     let stat = match cache.stat.get() {
@@ -370,7 +370,7 @@ impl Cpu {
   }
 
   fn scan_info(&mut self, cache: &CpuScanCache) -> anyhow::Result<()> {
-    log::trace!("scanning info for CPU {}", self.number);
+    log::trace!("scanning info for CPU {number}", number = self.number);
 
     // OnceCell::get_or_try_init is unstable. Cope:
     let info = match cache.info.get() {
@@ -459,7 +459,7 @@ impl Cpu {
 
     self.governor = Some(governor.to_owned());
 
-    log::info!("CPU {} governor set to {}", self.number, governor);
+    log::info!("CPU {number} governor set to {governor}", number = self.number);
 
     Ok(())
   }
@@ -495,7 +495,7 @@ impl Cpu {
 
     self.epp = Some(epp.to_owned());
 
-    log::info!("CPU {} EPP set to {}", self.number, epp);
+    log::info!("CPU {number} EPP set to {epp}", number = self.number);
 
     Ok(())
   }
@@ -530,7 +530,7 @@ impl Cpu {
 
     self.epb = Some(epb.to_owned());
 
-    log::info!("CPU {} EPB set to {}", self.number, epb);
+    log::info!("CPU {number} EPB set to {epb}", number = self.number);
 
     Ok(())
   }
@@ -559,9 +559,8 @@ impl Cpu {
     })?;
 
     log::info!(
-      "CPU {} min frequency set to {} MHz",
-      self.number,
-      frequency_mhz
+      "CPU {number} min frequency set to {frequency_mhz} MHz",
+      number = self.number,
     );
 
     Ok(())
@@ -585,8 +584,8 @@ impl Cpu {
     if new_frequency_mhz * 1000 < minimum_frequency_khz {
       bail!(
         "new software minimum frequency ({new_frequency_mhz} MHz) cannot be \
-         lower than the hardware minimum frequency ({} MHz) for {self}",
-        minimum_frequency_khz / 1000,
+         lower than the hardware minimum frequency ({mhz} MHz) for {self}",
+        mhz = minimum_frequency_khz / 1000,
       );
     }
 
@@ -617,9 +616,8 @@ impl Cpu {
     })?;
 
     log::info!(
-      "CPU {} max frequency set to {} MHz",
-      self.number,
-      frequency_mhz
+      "CPU {number} max frequency set to {frequency_mhz} MHz",
+      number = self.number,
     );
 
     Ok(())
@@ -645,8 +643,8 @@ impl Cpu {
     if new_frequency_mhz * 1000 > maximum_frequency_khz {
       bail!(
         "new software maximum frequency ({new_frequency_mhz} MHz) cannot be \
-         higher than the hardware maximum frequency ({} MHz) for {self}",
-        maximum_frequency_khz / 1000,
+         higher than the hardware maximum frequency ({mhz} MHz) for {self}",
+        mhz = maximum_frequency_khz / 1000,
       );
     }
 

watt/fs.rs

@@ -25,7 +25,7 @@ pub fn read_dir(path: impl AsRef<Path>) -> anyhow::Result<Option<fs::ReadDir>> {
     Err(error) => {
       Err(error).context(format!(
         "failed to read directory '{path}'",
-        path = path.display()
+        path = path.display(),
       ))
     },
   }

watt/lock.rs

@@ -38,9 +38,13 @@ pub struct LockFileError {
 
 impl fmt::Display for LockFileError {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(f, "failed to acquire lock on {}", self.path.display())?;
-    if let Some(msg) = &self.message {
-      write!(f, ": {}", msg)?;
+    write!(
+      f,
+      "failed to acquire lock on {path}",
+      path = self.path.display(),
+    )?;
+    if let Some(message) = &self.message {
+      write!(f, ": {message}")?;
     }
     Ok(())
   }
@@ -69,28 +73,26 @@ impl LockFile {
 
   pub fn acquire(lock_path: &Path) -> Result<Self, LockFileError> {
     // Ensure parent directory exists with proper permissions
-    if let Some(parent) = lock_path.parent() {
-      if !parent.exists() {
-        fs::DirBuilder::new()
-          .mode(0o755)
-          .recursive(true)
-          .create(parent)
-          .map_err(|error| {
-            log::error!(
-              "failed to create lock directory {}: {}",
-              parent.display(),
-              error
-            );
-            LockFileError {
-              path:    lock_path.to_owned(),
-              message: Some(format!(
-                "cannot create directory {}: {}",
-                parent.display(),
-                error
-              )),
-            }
-          })?;
-      }
+    if let Some(parent) = lock_path.parent()
+      && !parent.exists()
+    {
+      fs::DirBuilder::new()
+        .mode(0o755)
+        .recursive(true)
+        .create(parent)
+        .map_err(|error| {
+          log::error!(
+            "failed to create lock directory {parent}: {error}",
+            parent = parent.display(),
+          );
+          LockFileError {
+            path:    lock_path.to_owned(),
+            message: Some(format!(
+              "cannot create directory {parent}: {error}",
+              parent = parent.display(),
+            )),
+          }
+        })?;
     }
 
     #[allow(clippy::suspicious_open_options)]
@@ -102,9 +104,8 @@ impl LockFile {
       .open(lock_path)
       .map_err(|error| {
         log::error!(
-          "failed to open lock file at {}: {}",
-          lock_path.display(),
-          error
+          "failed to open lock file at {path}: {error}",
+          path = lock_path.display(),
         );
         LockFileError {
           path:    lock_path.to_owned(),
@@ -116,12 +117,12 @@ impl LockFile {
       |(_, error)| {
         let message = if error == nix::errno::Errno::EWOULDBLOCK {
           log::error!(
-            "another watt instance is already running (lock held on {})",
-            lock_path.display()
+            "another watt instance is already running (lock held on {path})",
+            path = lock_path.display(),
           );
           Some("another instance is running".to_string())
         } else {
-          log::error!("failed to acquire lock: {}", error);
+          log::error!("failed to acquire lock: {error}");
           Some(error.to_string())
         };
 

watt/power_supply.rs

@@ -170,13 +170,13 @@ impl PowerSupply {
       power_supplies.push(power_supply);
     }
 
-    log::info!("detected {} power supplies", power_supplies.len());
+    log::info!("detected {len} power supplies", len = power_supplies.len());
 
     Ok(power_supplies)
   }
 
   fn scan(&mut self) -> anyhow::Result<()> {
-    log::trace!("scanning power supply '{}'", self.name);
+    log::trace!("scanning power supply '{name}'", name = self.name);
 
     if !self.path.exists() {
       bail!("{self} does not exist");
@@ -197,7 +197,7 @@ impl PowerSupply {
     self.is_from_peripheral = 'is_from_peripheral: {
       let name_lower = self.name.to_lowercase();
 
-      log::trace!("power supply '{}' type: {}", self.name, self.type_);
+      log::trace!("power supply '{name}' type: {type_}", name = self.name, type_ = self.type_);
 
       // Common peripheral battery names.
       if name_lower.contains("mouse")
@@ -293,9 +293,9 @@ impl PowerSupply {
         .copied();
 
       log::debug!(
-        "power supply '{}' threshold config: {:?}",
-        self.name,
-        self.threshold_config
+        "power supply '{name}' threshold config: {threshold_config:?}",
+        name = self.name,
+        threshold_config = self.threshold_config,
       );
     }
 

watt/system.rs

@@ -406,7 +406,7 @@ impl System {
       };
       log::debug!(
         "temperature content: {celsius} celsius",
-        celsius = temperature_mc as f64 / 1000.0
+        celsius = temperature_mc as f64 / 1000.0,
       );
 
       temperatures.insert(number, temperature_mc as f64 / 1000.0);
@@ -830,6 +830,11 @@ pub fn run_daemon(config: config::DaemonConfig) -> anyhow::Result<()> {
         .context("`if` was not a boolean")?;
 
       if condition {
+        log::info!(
+          "rule '{name}' condition evaluated to true! evaluating members...",
+          name = rule.name,
+        );
+
         let cpu_some = {
           let (cpu_deltas_lo, cpu_turbo_lo) = rule.cpu.eval(&state)?;
 
@@ -883,16 +888,16 @@ pub fn run_daemon(config: config::DaemonConfig) -> anyhow::Result<()> {
         .with_context(|| format!("failed to apply delta to {cpu}"))?;
     }
 
-    log::info!("applying CPU deltas to {} CPUs", cpu_deltas.len());
+    log::info!("applying CPU deltas to {len} CPUs", len = cpu_deltas.len());
 
     if let Some(turbo) = cpu_turbo {
       cpu::Cpu::set_turbo(turbo, cpu_deltas.keys().map(|arc| &**arc))
         .context("failed to set CPU turbo")?;
     }
 
     log::info!(
-      "applying power supply deltas to {} devices",
-      power_deltas.len()
+      "applying power supply deltas to {len} devices",
+      len = power_deltas.len(),
     );
 
     for (power, delta) in power_deltas {