replace ErrorBox with anyhow::Error

Author: max-baz

src/als/iio.rs

@@ -1,5 +1,5 @@
 use crate::device_file::read;
-use crate::ErrorBox;
+use anyhow::{anyhow, Error, Result};
 use futures_util::{FutureExt, StreamExt, TryFutureExt};
 use smol::fs::File;
 use smol::lock::Mutex;
@@ -28,10 +28,10 @@ pub struct Als {
 }
 
 impl Als {
-    pub async fn new(base_path: &str, thresholds: HashMap<u64, String>) -> Result<Self, ErrorBox> {
+    pub async fn new(base_path: &str, thresholds: HashMap<u64, String>) -> Result<Self> {
         smol::fs::read_dir(base_path)
             .await
-            .map_err(|e| ErrorBox::from(format!("Can't enumerate iio devices: {e}")))?
+            .map_err(|e| anyhow!("Can't enumerate iio devices: {e}"))?
             .filter_map(|r| async { r.ok() })
             .then(|entry| {
                 smol::fs::read_to_string(entry.path().join("name")).map(|name| (name, entry))
@@ -58,18 +58,18 @@ impl Als {
             .next()
             .await
             .map(|sensor| Self { sensor, thresholds })
-            .ok_or_else(|| ErrorBox::from("No iio device found"))
+            .ok_or_else(|| anyhow!("No iio device found"))
     }
 
-    pub async fn get(&self) -> Result<String, ErrorBox> {
+    pub async fn get(&self) -> Result<String> {
         let raw = self.get_raw().await?;
         let profile = super::find_profile(raw, &self.thresholds);
 
         log::trace!("ALS (iio): {} ({})", profile, raw);
         Ok(profile)
     }
 
-    async fn get_raw(&self) -> Result<u64, ErrorBox> {
+    async fn get_raw(&self) -> Result<u64> {
         Ok(match self.sensor {
             Illuminance {
                 ref value,
@@ -90,7 +90,7 @@ impl Als {
     }
 }
 
-async fn parse_illuminance_raw(path: PathBuf) -> Result<SensorType, ErrorBox> {
+async fn parse_illuminance_raw(path: PathBuf) -> Result<SensorType> {
     Ok(Illuminance {
         value: Mutex::new(
             open_file(&path, "in_illuminance_raw")
@@ -114,8 +114,8 @@ async fn parse_illuminance_raw(path: PathBuf) -> Result<SensorType, ErrorBox> {
     })
 }
 
-async fn parse_intensity_raw(path: PathBuf) -> Result<SensorType, ErrorBox> {
-    async fn try_open_and_read(path: &Path, name: &str) -> Result<f64, ErrorBox> {
+async fn parse_intensity_raw(path: PathBuf) -> Result<SensorType> {
+    async fn try_open_and_read(path: &Path, name: &str) -> Result<f64> {
         let mut f = open_file(path, name).await?;
         read(&mut f).await
     }
@@ -131,7 +131,7 @@ async fn parse_intensity_raw(path: PathBuf) -> Result<SensorType, ErrorBox> {
     })
 }
 
-async fn parse_illuminance_input(path: PathBuf) -> Result<SensorType, ErrorBox> {
+async fn parse_illuminance_input(path: PathBuf) -> Result<SensorType> {
     Ok(Illuminance {
         value: Mutex::new(
             open_file(&path, "in_illuminance_input")
@@ -143,14 +143,14 @@ async fn parse_illuminance_input(path: PathBuf) -> Result<SensorType, ErrorBox>
     })
 }
 
-async fn parse_intensity_rgb(path: PathBuf) -> Result<SensorType, ErrorBox> {
+async fn parse_intensity_rgb(path: PathBuf) -> Result<SensorType> {
     Ok(Intensity {
         r: Mutex::new(open_file(&path, "in_intensity_red_raw").await?),
         g: Mutex::new(open_file(&path, "in_intensity_green_raw").await?),
         b: Mutex::new(open_file(&path, "in_intensity_blue_raw").await?),
     })
 }
 
-async fn open_file(path: &Path, name: &str) -> Result<File, ErrorBox> {
-    File::open(path.join(name)).await.map_err(ErrorBox::from)
+async fn open_file(path: &Path, name: &str) -> Result<File> {
+    File::open(path.join(name)).await.map_err(Error::msg)
 }

src/als/mod.rs

@@ -1,8 +1,7 @@
+use anyhow::Result;
 use itertools::Itertools;
 use std::collections::HashMap;
 
-use crate::ErrorBox;
-
 pub mod controller;
 pub mod iio;
 pub mod none;
@@ -18,7 +17,7 @@ pub enum Als {
 }
 
 impl Als {
-    pub async fn get(&self) -> Result<String, ErrorBox> {
+    pub async fn get(&self) -> Result<String> {
         match self {
             Als::Webcam(als) => als.get().await,
             Als::Iio(als) => als.get().await,

src/als/none.rs

@@ -1,10 +1,10 @@
-use crate::ErrorBox;
+use anyhow::Result;
 
 #[derive(Default)]
 pub struct Als {}
 
 impl Als {
-    pub async fn get(&self) -> Result<String, ErrorBox> {
+    pub async fn get(&self) -> Result<String> {
         Ok("none".to_string())
     }
 }

src/als/time.rs

@@ -1,8 +1,7 @@
+use anyhow::Result;
 use chrono::{Local, Timelike};
 use std::collections::HashMap;
 
-use crate::ErrorBox;
-
 pub struct Als {
     thresholds: HashMap<u64, String>,
 }
@@ -12,7 +11,7 @@ impl Als {
         Self { thresholds }
     }
 
-    pub async fn get(&self) -> Result<String, ErrorBox> {
+    pub async fn get(&self) -> Result<String> {
         let raw = Local::now().hour() as u64;
         let profile = super::find_profile(raw, &self.thresholds);
 

src/als/webcam.rs

@@ -1,6 +1,6 @@
 use crate::channel_ext::ReceiverExt;
 use crate::frame::compute_perceived_lightness_percent;
-use crate::ErrorBox;
+use anyhow::{anyhow, Result};
 use itertools::Itertools;
 use smol::channel::{Receiver, Sender};
 use smol::lock::Mutex;
@@ -44,15 +44,15 @@ impl Webcam {
         thread::sleep(Duration::from_millis(WAITING_SLEEP_MS));
     }
 
-    fn frame(&mut self) -> Result<(Vec<u8>, usize), ErrorBox> {
+    fn frame(&mut self) -> Result<(Vec<u8>, usize)> {
         let (device, pixels) = Self::setup(self.video)?;
         let mut stream = Stream::new(&device, Type::VideoCapture)?;
         let (rgbs, _) = stream.next()?;
 
         Ok((rgbs.to_vec(), pixels))
     }
 
-    fn setup(video: usize) -> Result<(Device, usize), ErrorBox> {
+    fn setup(video: usize) -> Result<(Device, usize)> {
         let device = Device::new(video)?;
         let mut format = device.format()?;
         format.fourcc = FourCC::new(b"RGB3");
@@ -67,7 +67,7 @@ impl Webcam {
                     .collect_vec()
             })
             .min_by(|&(w1, h1), &(w2, h2)| h1.cmp(&h2).then(w1.cmp(&w2)))
-            .ok_or("Unable to find minimum resolution")?;
+            .ok_or(anyhow!("Unable to find minimum resolution"))?;
 
         format.height = height;
         format.width = width;
@@ -92,15 +92,15 @@ impl Als {
         }
     }
 
-    pub async fn get(&self) -> Result<String, ErrorBox> {
+    pub async fn get(&self) -> Result<String> {
         let raw = self.get_raw().await?;
         let profile = super::find_profile(raw, &self.thresholds);
 
         log::trace!("ALS (webcam): {} ({})", profile, raw);
         Ok(profile)
     }
 
-    async fn get_raw(&self) -> Result<u64, ErrorBox> {
+    async fn get_raw(&self) -> Result<u64> {
         let new_value = self
             .webcam_rx
             .recv_maybe_last()
@@ -127,15 +127,15 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn test_get_raw_returns_default_value_when_no_data_from_webcam() -> Result<(), ErrorBox> {
+    async fn test_get_raw_returns_default_value_when_no_data_from_webcam() -> Result<()> {
         let (als, _) = setup().await;
 
         assert_eq!(DEFAULT_LUX, als.get_raw().await?);
         Ok(())
     }
 
     #[apply(test!)]
-    async fn test_get_raw_returns_value_from_webcam() -> Result<(), ErrorBox> {
+    async fn test_get_raw_returns_value_from_webcam() -> Result<()> {
         let (als, webcam_tx) = setup().await;
 
         webcam_tx.send(42).await?;
@@ -145,7 +145,7 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn test_get_raw_returns_most_recent_value_from_webcam() -> Result<(), ErrorBox> {
+    async fn test_get_raw_returns_most_recent_value_from_webcam() -> Result<()> {
         let (als, webcam_tx) = setup().await;
 
         webcam_tx.send(42).await?;
@@ -157,8 +157,7 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn test_get_raw_returns_last_known_value_from_webcam_when_no_new_data(
-    ) -> Result<(), ErrorBox> {
+    async fn test_get_raw_returns_last_known_value_from_webcam_when_no_new_data() -> Result<()> {
         let (als, webcam_tx) = setup().await;
 
         webcam_tx.send(42).await?;

src/brightness/backlight.rs

@@ -1,5 +1,5 @@
 use crate::device_file::{read, write};
-use crate::ErrorBox;
+use anyhow::{anyhow, Error, Result};
 use dbus::channel::Sender;
 use dbus::{self, blocking::Connection, Message};
 use inotify::{Inotify, WatchMask};
@@ -25,7 +25,7 @@ pub struct Backlight {
 }
 
 impl Backlight {
-    pub async fn new(path: &str, min_brightness: u64) -> Result<Self, ErrorBox> {
+    pub async fn new(path: &str, min_brightness: u64) -> Result<Self> {
         let brightness_path = Path::new(path).join("brightness");
 
         let current_brightness = fs::read(&brightness_path)?;
@@ -47,7 +47,7 @@ impl Backlight {
             let id = Path::new(path)
                 .file_name()
                 .and_then(|x| x.to_str())
-                .ok_or("Unable to identify backlight ID")?;
+                .ok_or(anyhow!("Unable to identify backlight ID"))?;
 
             let subsystem = Path::new(path)
                 .parent()
@@ -57,7 +57,7 @@ impl Backlight {
                     "backlight" | "leds" => Some(x),
                     _ => None,
                 })
-                .ok_or(format!(
+                .ok_or(anyhow!(
                     "Unable to identify backlight subsystem out of {path}, please open an issue on GitHub"
                 ))?;
 
@@ -107,8 +107,8 @@ impl Backlight {
         })
     }
 
-    pub async fn get(&mut self) -> Result<u64, ErrorBox> {
-        async fn update(this: &mut Backlight) -> Result<u64, ErrorBox> {
+    pub async fn get(&mut self) -> Result<u64> {
+        async fn update(this: &mut Backlight) -> Result<u64> {
             let value = read(&mut this.file).await? as u64;
             this.current = Some(value);
             Ok(value)
@@ -130,15 +130,20 @@ impl Backlight {
         }
     }
 
-    pub async fn set(&mut self, value: u64) -> Result<u64, ErrorBox> {
+    pub async fn set(&mut self, value: u64) -> Result<u64> {
         let value = value.clamp(self.min_brightness, self.max_brightness);
 
         if self.has_write_permission {
             write(&mut self.file, value as f64).await?;
         } else if let Some(dbus) = &self.dbus {
             dbus.connection
-                .send(dbus.message.duplicate()?.append1(value as u32))
-                .map_err(|_| "Unable to send brightness change message via dbus")?;
+                .send(
+                    dbus.message
+                        .duplicate()
+                        .map_err(Error::msg)?
+                        .append1(value as u32),
+                )
+                .map_err(|_| anyhow!("Unable to send brightness change message via dbus"))?;
             self.pending_dbus_write = true;
         } else {
             Err(std::io::Error::from(ErrorKind::PermissionDenied))?

src/brightness/controller.rs

@@ -131,7 +131,7 @@ impl Controller {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ErrorBox;
+    use anyhow::Result;
     use macro_rules_attribute::apply;
     use smol::channel;
     use smol_macros::test;
@@ -160,7 +160,7 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn test_step_first_run() -> Result<(), ErrorBox> {
+    async fn test_step_first_run() -> Result<()> {
         let (mut controller, prediction_tx, user_rx) = setup(brightness_mock(vec![42], vec![]));
 
         // even if predictor already wants a change...
@@ -179,7 +179,7 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn test_step_first_run_brightness_zero() -> Result<(), ErrorBox> {
+    async fn test_step_first_run_brightness_zero() -> Result<()> {
         // if the current brightness value is zero...
         let (mut controller, prediction_tx, user_rx) = setup(brightness_mock(vec![0], vec![]));
 
@@ -199,7 +199,7 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn test_step_user_changed_brightness() -> Result<(), ErrorBox> {
+    async fn test_step_user_changed_brightness() -> Result<()> {
         let (mut controller, prediction_tx, user_rx) = setup(brightness_mock(vec![42], vec![]));
 
         // when last brightness differs from the current one

src/brightness/ddcutil.rs

@@ -1,10 +1,9 @@
+use anyhow::{anyhow, Result};
 use ddc_hi::{Ddc, Display, FeatureCode};
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use smol::lock::Mutex;
 
-use crate::ErrorBox;
-
 lazy_static! {
     static ref DDC_MUTEX: Mutex<()> = Mutex::new(());
 }
@@ -18,10 +17,10 @@ pub struct DdcUtil {
 }
 
 impl DdcUtil {
-    pub fn new(name: &str, min_brightness: u64) -> Result<Self, ErrorBox> {
+    pub fn new(name: &str, min_brightness: u64) -> Result<Self> {
         let mut display = find_display_by_name(name, true)
             .or_else(|| find_display_by_name(name, false))
-            .ok_or("Unable to find display")?;
+            .ok_or(anyhow!("Unable to find display"))?;
         let max_brightness = get_max_brightness(&mut display)?;
 
         Ok(Self {
@@ -31,7 +30,7 @@ impl DdcUtil {
         })
     }
 
-    pub async fn get(&mut self) -> Result<u64, ErrorBox> {
+    pub async fn get(&mut self) -> Result<u64> {
         let _lock = DDC_MUTEX.lock().await;
         Ok(self
             .display
@@ -41,7 +40,7 @@ impl DdcUtil {
             .value() as u64)
     }
 
-    pub async fn set(&mut self, value: u64) -> Result<u64, ErrorBox> {
+    pub async fn set(&mut self, value: u64) -> Result<u64> {
         let _lock = DDC_MUTEX.lock().await;
         let value = value.clamp(self.min_brightness, self.max_brightness);
         self.display
@@ -52,7 +51,7 @@ impl DdcUtil {
     }
 }
 
-fn get_max_brightness(display: &mut Display) -> Result<u64, ErrorBox> {
+fn get_max_brightness(display: &mut Display) -> Result<u64> {
     Ok(display
         .handle
         .get_vcp_feature(DDC_BRIGHTNESS_FEATURE)?