clippy fix

src/arpparse/mod.rs

@@ -1,2 +1,2 @@
-pub use wakey_core::{NeighborEntry as IpNeighLine, NeighborParseError as IPNeighParseError};
-pub use wakey_core::{NeighborState as NUDState, parse_neighbor_line};
+pub use wakey_core::NeighborEntry as IpNeighLine;
+pub use wakey_core::NeighborState as NUDState;

src/dhcpparse.rs

@@ -1,4 +1,3 @@
-pub use wakey_core::DhcpLease as DhcpLeaseLine;
 pub use wakey_linux::dhcp::{
-    load_mac_name_cache, parse_dhcp_lease_line, read_dhcp_leases, read_dhcp_leases_with_names,
+    load_mac_name_cache, read_dhcp_leases_with_names,
 };

src/route/status.rs

@@ -2,7 +2,7 @@ use crate::route::error::ApiError;
 use axum::{Json, http::StatusCode, response::IntoResponse};
 use axum_extra::extract::Query;
 use crate::utils::query::get_macs;
-pub use wakey_core::{DeviceFilters as Filters, DeviceQuery, NamePath, Status};
+pub use wakey_core::{DeviceQuery, NamePath, Status};
 
 pub async fn get_status_json(
     Query(DeviceQuery {

src/route/wake/mod.rs

@@ -8,7 +8,7 @@ use crate::route::error::ApiError;
 use axum::{extract::Json, http::StatusCode, response::IntoResponse};
 use futures::TryFutureExt;
 use tokio::net::UdpSocket;
-pub use wakey_core::{WakeResult, WakeStatus as WakeTargetStatus, WakeTarget, WakeTargetResult};
+pub use wakey_core::{WakeResult, WakeTarget, WakeTargetResult};
 
 pub async fn wake_multi(Json(req): Json<Vec<WakeTarget>>) -> impl IntoResponse {
     match wake_multi_split(req).await {
@@ -34,7 +34,7 @@ pub async fn wake_multi_split(
             WakeTargetResult::incomplete(c)
         } else {
             let t = c.try_into().expect("complete struct failed to try_into");
-            wake_one(&sock, t).await.into()
+            wake_one(&sock, t).await
         }
     });
     Ok(futures::future::join_all(iter).await)

src/utils/parse/mac.rs

@@ -1,47 +0,0 @@
-use macaddr::MacAddr;
-use serde::{self, Deserialize, Deserializer, de::Error as DeError};
-use serde::{Serialize, Serializer, de};
-
-pub fn _serialize_macs<S>(macs: &[MacAddr], serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let strings: Vec<String> = macs.iter().map(|m| m.to_string()).collect();
-    serde::Serialize::serialize(&strings, serializer)
-}
-
-/// Serialize a MacAddr as a string
-pub fn serialize<S>(mac: &MacAddr, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    serializer.serialize_str(&mac.to_string())
-}
-
-/// Deserialize a MacAddr from a string
-pub fn _deserialize<'de, D>(deserializer: D) -> Result<MacAddr, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let s = <String as serde::Deserialize>::deserialize(deserializer)?;
-    s.parse::<MacAddr>().map_err(DeError::custom)
-}
-
-pub mod option_mac {
-    use super::*;
-    /// serialize an [`Option<MacAddr>`]
-    pub fn serialize<S: Serializer>(bro: &Option<MacAddr>, ser: S) -> Result<S::Ok, S::Error> {
-        Option::<String>::serialize(&bro.as_ref().map(ToString::to_string), ser)
-    }
-
-    /// deserialize an [`Option<MacAddr>`]
-    pub fn deserialize<'de, D>(des: D) -> Result<Option<MacAddr>, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        Option::<&str>::deserialize(des)?
-            .map(str::parse)
-            .transpose()
-            .map_err(de::Error::custom)
-    }
-}

src/utils/parse/mod.rs

@@ -1,63 +1,3 @@
-/// Parses Chrome-style numeric IPv4 forms: hex (0x...), decimal, octal.
-pub fn parse_numeric_ipv4(s: &str) -> Option<std::net::IpAddr> {
-    let s = s.trim();
-    // hex
-    if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X"))
-        && hex.chars().all(|c| c.is_ascii_hexdigit())
-        && let Ok(n) = u32::from_str_radix(hex, 16)
-    {
-        return Some(std::net::IpAddr::V4(std::net::Ipv4Addr::from(n)));
-    }
-    // decimal
-    if s.chars().all(|c| c.is_ascii_digit())
-        && let Ok(n) = s.parse::<u32>()
-    {
-        return Some(std::net::IpAddr::V4(std::net::Ipv4Addr::from(n)));
-    }
-    // octal (leading 0, all octal digits)
-    if s.len() > 1
-        && s.as_bytes()[0] == b'0'
-        && s.chars().all(|c| matches!(c, '0'..='7'))
-        && let Ok(n) = u32::from_str_radix(s, 8)
-    {
-        return Some(std::net::IpAddr::V4(std::net::Ipv4Addr::from(n)));
-    }
-    None
-}
-/// Extracts the host portion from a URL-like string, for smart input parsing.
-pub fn extract_host(input: &str) -> &str {
-    let mut s = input.trim();
-    // Strip scheme (e.g., http://, https://, ssh://) or network-path reference (//host)
-    if let Some(idx) = s.find("://") {
-        s = &s[idx + 3..];
-    } else if let Some(rest) = s.strip_prefix("//") {
-        s = rest;
-    }
-    // Strip potential userinfo (user@host)
-    if let Some((_, host)) = s.rsplit_once('@') {
-        s = host;
-    }
-    // If bracketed IPv6 like [::1]:8080/path -> extract inside brackets
-    if let Some(host) = s.strip_prefix('[') {
-        if let Some(end) = host.find(']') {
-            s = &host[..end];
-        }
-    } else {
-        // Trim path suffix if any
-        if let Some(pos) = s.find('/') {
-            s = &s[..pos];
-        }
-        // Drop trailing :port if present and numeric, but only if there's exactly one ':'
-        if let Some((host, port)) = s.rsplit_once(':')
-            && s.matches(':').count() == 1
-            && port.chars().all(|c| c.is_ascii_digit())
-        {
-            s = host;
-        }
-    }
-    s.trim()
-}
-
 /// key for yes: "1" | "true" | "yes" | "on" | "y"
 ///
 /// frfr
@@ -100,4 +40,3 @@ pub fn boolish_str(s: &str) -> bool {
             && t.parse::<u64>().map(|n| n != 0).unwrap_or(false))
 }
 
-pub mod mac;

src/utils/query/dev.rs

@@ -1 +1 @@
-pub use wakey_linux::devices::{devs_sorted, has_dev};
+pub use wakey_linux::devices::devs_sorted;

src/utils/query/leases.rs

@@ -1,2 +1 @@
-pub use wakey_core::DhcpLeaseWithState as DhcpLeaseOut;
 pub use wakey_linux::dhcp::enrich_leases_with_nud_state;

src/utils/wake.rs

@@ -5,5 +5,3 @@ pub async fn wake_one(
     wakey_linux::wake::wake_one(sock, t).await
 }
 
-pub use wakey_linux::wake::{CompleteWakeTarget as WakeTarget, wake_many as _wake_multi};
-pub use wakey_core::{WakeStatus, WakeTargetResult};