fix(application): address clippy warnings

- xtask: replace manual div_ceil expression with .div_ceil()
- storage: remove blank line after doc comment; remove unused
  KEY_INIT constant
- auth: suppress dead_code on AdminUser tuple field (inner
  AuthUser accessible via .0 for future use)
- gpio: refactor gpio_task to accept [Output; 8] array instead
  of 8 individual arguments to satisfy clippy::too_many_arguments
- main: add EthernetRunner type alias to resolve
  clippy::type_complexity on ethernet_task signature

Co-authored-by: Claude <noreply@anthropic.com>
Signed-off-by: Marvin Drees <marvin.drees@9elements.com>

Author: MDr164

application/src/auth.rs

@@ -153,6 +153,8 @@ impl<'r> FromRequestParts<'r, ()> for AuthUser {
 // ── AdminUser ─────────────────────────────────────────────────────────────────
 
 /// Wrapper extractor that requires the authenticated user to be an admin.
+/// The inner `AuthUser` is available for handlers that need it via `.0`.
+#[allow(dead_code)]
 pub struct AdminUser(pub AuthUser);
 
 /// Returned when an authenticated-but-non-admin user tries to access an admin route.

application/src/gpio.rs

@@ -25,16 +25,7 @@ pub static GPIO_STATES: Mutex<CriticalSectionRawMutex, [bool; 8]> = Mutex::new([
 /// Listens on `GPIO_SIGNAL` for commands and updates both the pin hardware
 /// and the shared `GPIO_STATES` mutex.
 #[embassy_executor::task]
-pub async fn gpio_task(
-    mut pin0: Output<'static>,
-    mut pin1: Output<'static>,
-    mut pin2: Output<'static>,
-    mut pin3: Output<'static>,
-    mut pin4: Output<'static>,
-    mut pin5: Output<'static>,
-    mut pin6: Output<'static>,
-    mut pin7: Output<'static>,
-) {
+pub async fn gpio_task(mut pins: [Output<'static>; 8]) {
     loop {
         let cmd = GPIO_SIGNAL.wait().await;
 
@@ -58,65 +49,10 @@ pub async fn gpio_task(
         };
 
         // Drive the hardware pin
-        let set_high = new_state;
-        match pin_index {
-            0 => {
-                if set_high {
-                    pin0.set_high();
-                } else {
-                    pin0.set_low();
-                }
-            }
-            1 => {
-                if set_high {
-                    pin1.set_high();
-                } else {
-                    pin1.set_low();
-                }
-            }
-            2 => {
-                if set_high {
-                    pin2.set_high();
-                } else {
-                    pin2.set_low();
-                }
-            }
-            3 => {
-                if set_high {
-                    pin3.set_high();
-                } else {
-                    pin3.set_low();
-                }
-            }
-            4 => {
-                if set_high {
-                    pin4.set_high();
-                } else {
-                    pin4.set_low();
-                }
-            }
-            5 => {
-                if set_high {
-                    pin5.set_high();
-                } else {
-                    pin5.set_low();
-                }
-            }
-            6 => {
-                if set_high {
-                    pin6.set_high();
-                } else {
-                    pin6.set_low();
-                }
-            }
-            7 => {
-                if set_high {
-                    pin7.set_high();
-                } else {
-                    pin7.set_low();
-                }
-            }
-            _ => {}
+        if new_state {
+            pins[pin_index].set_high();
+        } else {
+            pins[pin_index].set_low();
         }
     }
 }

application/src/main.rs

@@ -58,16 +58,17 @@ bind_interrupts!(struct Irqs {
 
 // ── Ethernet task ──────────────────────────────────────────────────────────────
 
+/// Type alias for the W5500 runner to avoid repeating the full generic signature.
+type EthernetRunner = Runner<
+    'static,
+    W5500,
+    ExclusiveDevice<Spi<'static, SPI0, Async>, Output<'static>, embassy_time::Delay>,
+    Input<'static>,
+    Output<'static>,
+>;
+
 #[embassy_executor::task]
-async fn ethernet_task(
-    runner: Runner<
-        'static,
-        W5500,
-        ExclusiveDevice<Spi<'static, SPI0, Async>, Output<'static>, embassy_time::Delay>,
-        Input<'static>,
-        Output<'static>,
-    >,
-) -> ! {
+async fn ethernet_task(runner: EthernetRunner) -> ! {
     runner.run().await
 }
 
@@ -112,17 +113,19 @@ async fn main(spawner: Spawner) {
     web::init_db(db);
 
     // 4. GPIO outputs for 8 relay outputs (PIN_0 – PIN_7)
-    let pin0 = Output::new(p.PIN_0, Level::Low);
-    let pin1 = Output::new(p.PIN_1, Level::Low);
-    let pin2 = Output::new(p.PIN_2, Level::Low);
-    let pin3 = Output::new(p.PIN_3, Level::Low);
-    let pin4 = Output::new(p.PIN_4, Level::Low);
-    let pin5 = Output::new(p.PIN_5, Level::Low);
-    let pin6 = Output::new(p.PIN_6, Level::Low);
-    let pin7 = Output::new(p.PIN_7, Level::Low);
+    let relay_pins = [
+        Output::new(p.PIN_0, Level::Low),
+        Output::new(p.PIN_1, Level::Low),
+        Output::new(p.PIN_2, Level::Low),
+        Output::new(p.PIN_3, Level::Low),
+        Output::new(p.PIN_4, Level::Low),
+        Output::new(p.PIN_5, Level::Low),
+        Output::new(p.PIN_6, Level::Low),
+        Output::new(p.PIN_7, Level::Low),
+    ];
 
     // 6. Spawn GPIO task
-    spawner.spawn(gpio_task(pin0, pin1, pin2, pin3, pin4, pin5, pin6, pin7).unwrap());
+    spawner.spawn(gpio_task(relay_pins).unwrap());
 
     // 7. Init W5500 Ethernet (SPI0, DMA_CH0 TX, DMA_CH1 RX)
     let mut spi_cfg = SpiConfig::default();

application/src/storage.rs

@@ -111,8 +111,6 @@ pub async fn init_database(
 // ── Schema key helpers ─────────────────────────────────────────────────────────
 
 /// ekv key constants (sorted: "admin/..." < "init" < "p/..." < "u/...")
-
-pub const KEY_INIT: &[u8] = b"init";
 pub const KEY_ADMIN_FIRST_LOGIN: &[u8] = b"admin/first_login";
 
 /// Build port name key: `b"p/{port}/name"` (port 0–7)

xtask/src/main.rs

@@ -238,7 +238,7 @@ const UF2_PAYLOAD_SIZE: usize = 256;
 
 /// Convert a flat binary image to UF2 format for RP2040.
 fn binary_to_uf2(data: &[u8], base_addr: u32) -> Vec<u8> {
-    let num_blocks = (data.len() + UF2_PAYLOAD_SIZE - 1) / UF2_PAYLOAD_SIZE;
+    let num_blocks = data.len().div_ceil(UF2_PAYLOAD_SIZE);
     let mut uf2 = Vec::with_capacity(num_blocks * 512);
 
     for (i, chunk) in data.chunks(UF2_PAYLOAD_SIZE).enumerate() {