fix(build): Fix build warnings and make test build errors

Author: pastaq

src/config/capability_map.rs

@@ -27,14 +27,13 @@ pub fn load_capability_mappings() -> HashMap<String, CapabilityMapConfig> {
         // Try to load the capability map
         log::trace!("Found file: {}", file.display());
         let mapping = CapabilityMapConfig::from_yaml_file(file.display().to_string());
-        if mapping.is_err() {
-            log::warn!(
-                "Failed to parse capability mapping: {}",
-                mapping.unwrap_err()
-            );
-            continue;
-        }
-        let map = mapping.unwrap();
+        let map = match mapping {
+            Ok(map) => map,
+            Err(e) => {
+                log::warn!("Failed to parse capability mapping: {e}",);
+                continue;
+            }
+        };
         mappings.insert(map.id(), map);
     }
 

src/dbus/interface/mod.rs

@@ -252,4 +252,4 @@ pub trait Unregisterable {
     }
 }
 
-type UnregisterFn = (dyn std::ops::Fn(Connection, String) + 'static + Send + Sync);
+type UnregisterFn = dyn std::ops::Fn(Connection, String) + 'static + Send + Sync;

src/dbus/interface/target/touchscreen.rs

@@ -5,9 +5,11 @@ use zbus_macros::interface;
 /// The [TargetTouchscreenInterface] provides a DBus interface that can be exposed for managing
 /// a [TouchscreenDevice]. It works by sending command messages to a channel that the
 /// [TouchscreenDevice] is listening on.
+#[allow(dead_code)]
 pub struct TargetTouchscreenInterface {}
 
 impl TargetTouchscreenInterface {
+    #[allow(dead_code)]
     pub fn new() -> TargetTouchscreenInterface {
         TargetTouchscreenInterface {}
     }
@@ -23,6 +25,7 @@ impl Default for TargetTouchscreenInterface {
 impl TargetTouchscreenInterface {
     /// Name of the target device
     #[zbus(property)]
+    #[allow(dead_code)]
     async fn name(
         &self,
         #[zbus(connection)] conn: &Connection,

src/drivers/unified_gamepad/reports.rs

@@ -60,6 +60,7 @@ impl From<u8> for ReportType {
 
 /// Feature report types
 #[derive(PrimitiveEnum_u8, Clone, Copy, PartialEq, Debug)]
+#[allow(dead_code)]
 pub enum FeatureReportType {
     /// Instruct the driver to return a feature report with the available capabilities
     GetInputCapabilities = 0x01,

src/input/composite_device/client.rs

@@ -24,7 +24,7 @@ const DEFAULT_TIMEOUT: Duration = Duration::from_secs(5);
 #[derive(Error, Debug)]
 pub enum ClientError {
     #[error("failed to send command to device: {0}")]
-    SendError(SendError<CompositeCommand>),
+    SendError(String),
     #[error("service encountered an error processing the request: {0}")]
     ServiceError(Box<dyn std::error::Error>),
     #[error("device no longer exists")]
@@ -33,7 +33,7 @@ pub enum ClientError {
 
 impl From<SendError<CompositeCommand>> for ClientError {
     fn from(err: SendError<CompositeCommand>) -> Self {
-        Self::SendError(err)
+        Self::SendError(err.to_string())
     }
 }
 

src/input/composite_device/mod.rs

@@ -730,10 +730,7 @@ impl CompositeDevice {
 
         // Only send valid events to the target device(s)
         if cap == Capability::NotImplemented {
-            log::trace!(
-                "Refusing to send '{}' event to target devices.",
-                cap.to_string()
-            );
+            log::trace!("Refusing to send '{cap}' event to target devices.");
             return Ok(());
         }
 

src/input/event/evdev.rs

@@ -936,13 +936,15 @@ fn input_event_from_value(
             // the minimum and maximum values for that axis depending on the
             // axis direction. This is typically done for DPad button input that
             // needs to be translated to an ABS_HAT axis input.
-            if axis_info.is_some() && axis_direction.is_some() {
-                let info = axis_info.unwrap();
-                let direction = axis_direction.unwrap();
-                match direction {
-                    AxisDirection::None => Some(value),
-                    AxisDirection::Positive => Some(info.maximum() * value),
-                    AxisDirection::Negative => Some(info.minimum() * value),
+            if let Some(info) = axis_info {
+                if let Some(direction) = axis_direction {
+                    match direction {
+                        AxisDirection::None => Some(value),
+                        AxisDirection::Positive => Some(info.maximum() * value),
+                        AxisDirection::Negative => Some(info.minimum() * value),
+                    }
+                } else {
+                    Some(value)
                 }
             } else {
                 Some(value)
@@ -971,8 +973,8 @@ fn input_event_from_value(
                     // Cannot denormalize value without axis info
                     EventType::ABSOLUTE => None,
                     EventType::RELATIVE => match RelativeAxisCode(code) {
-                        RelativeAxisCode::REL_X => Some(x? as i32),
-                        RelativeAxisCode::REL_Y => Some(y? as i32),
+                        RelativeAxisCode::REL_X => x.map(|v| v as i32),
+                        RelativeAxisCode::REL_Y => y.map(|v| v as i32),
                         _ => None,
                     },
                     _ => None,

src/input/manager.rs

@@ -299,7 +299,7 @@ impl Manager {
                     let path = device.keys().next().cloned();
                     let response = match path {
                         Some(path) => Ok(path),
-                        None => Err(ManagerError::CreateTargetDeviceFailed(
+                        _ => Err(ManagerError::CreateTargetDeviceFailed(
                             "Unable to find device path".to_string(),
                         )),
                     };
@@ -860,7 +860,7 @@ impl Manager {
         let tx = self.tx.clone();
         let task = tokio::spawn(async move {
             if let Err(e) = device.run().await {
-                log::error!("Error running {composite_path}: {}", e.to_string());
+                log::error!("Error running {composite_path}: {e}");
             }
             log::debug!("Composite device stopped running: {composite_path}");
             if let Err(e) = tx
@@ -870,8 +870,7 @@ impl Manager {
                 .await
             {
                 log::error!(
-                    "Error sending to composite device {composite_path} the stopped signal: {}",
-                    e.to_string()
+                    "Error sending to composite device {composite_path} the stopped signal: {e}"
                 );
             }
         });
@@ -1009,7 +1008,7 @@ impl Manager {
                     }
 
                     // Check if the composite device has to be unique (default to being unique)
-                    if source_device.unique.map_or_else(|| true, |unique| unique) {
+                    if source_device.unique.unwrap_or(true) {
                         log::trace!(
                             "Found unique device {:?}, not adding to composite device {composite_device}",
                             source_device
@@ -1659,15 +1658,16 @@ impl Manager {
                 // Try to load the composite device profile
                 log::trace!("Found file: {}", file.display());
                 let device = CompositeDeviceConfig::from_yaml_file(file.display().to_string());
-                if device.is_err() {
-                    log::warn!(
-                        "Failed to parse composite device config '{}': {}",
-                        file.display(),
-                        device.unwrap_err()
-                    );
-                    continue;
-                }
-                let device = device.unwrap();
+                let device = match device {
+                    Ok(dev) => dev,
+                    Err(e) => {
+                        log::warn!(
+                            "Failed to parse composite device config '{}': {e}",
+                            file.display()
+                        );
+                        continue;
+                    }
+                };
                 devices.push((file, device));
             }
 

src/input/source/evdev.rs

@@ -44,7 +44,7 @@ pub enum EventDevice {
 }
 
 impl SourceDeviceCompatible for EventDevice {
-    fn get_device_ref(&self) -> DeviceInfoRef {
+    fn get_device_ref(&self) -> DeviceInfoRef<'_> {
         match self {
             EventDevice::Blocked(source_driver) => source_driver.info_ref(),
             EventDevice::Gamepad(source_driver) => source_driver.info_ref(),

src/input/source/hidraw.rs

@@ -85,7 +85,7 @@ pub enum HidRawDevice {
 }
 
 impl SourceDeviceCompatible for HidRawDevice {
-    fn get_device_ref(&self) -> DeviceInfoRef {
+    fn get_device_ref(&self) -> DeviceInfoRef<'_> {
         match self {
             HidRawDevice::Blocked(source_driver) => source_driver.info_ref(),
             HidRawDevice::DualSense(source_driver) => source_driver.info_ref(),