what a plan! what an impl! this is ahh

src/utils/mod.rs

@@ -12,7 +12,3 @@
 // this is so bad
 pub mod ping;
 pub mod query;
-
-// no custom ip deserializer needed when using axum_extra::extract::Query
-// but we add a generic one to ignore blanks and accept OneOrMany
-pub(crate) mod parse;

src/utils/parse.rs

@@ -1,41 +0,0 @@
-/// key for yes: "1" | "true" | "yes" | "on" | "y"
-///
-/// frfr
-pub fn _de_boolish<'de, D>(des: D) -> Result<bool, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use serde::Deserialize;
-    #[derive(Deserialize)]
-    #[serde(untagged)]
-    enum Boolish {
-        B(bool),
-        I(u8),
-        S(String),
-    }
-    Ok(match Boolish::deserialize(des)? {
-        Boolish::B(b) => b,
-        Boolish::I(i) => i != 0,
-        Boolish::S(s) => {
-            let t = s.trim().to_ascii_lowercase();
-            if t.is_empty() {
-                true // presence implies true
-            } else {
-                matches!(t.as_str(), "1" | "true" | "yes" | "on" | "y")
-            }
-        }
-    })
-}
-
-/// Parse a tolerant boolean value from a string.
-/// Accepts: "1", "true", "yes", "on", "y" as true; "0", "false", "no", "off", "n" as false.
-/// Empty string means true (presence-only query flag).
-pub fn boolish_str(s: &str) -> bool {
-    let t = s.trim().to_ascii_lowercase();
-    if t.is_empty() {
-        return true;
-    }
-    matches!(t.as_str(), "1" | "true" | "yes" | "on" | "y")
-        || (!matches!(t.as_str(), "0" | "false" | "no" | "off" | "n")
-            && t.parse::<u64>().map(|n| n != 0).unwrap_or(false))
-}

src/utils/ping.rs

@@ -6,8 +6,9 @@ use tokio::{
     net::{TcpStream, ToSocketAddrs},
     time::timeout,
 };
+use wakey_core::NeighborState;
 
-use crate::{legacy::arpparse::NUDState, utils::query::get_mac};
+use crate::utils::query::get_mac;
 
 pub async fn _ping_ip<T: ToSocketAddrs>(addr: T) -> bool {
     timeout(Duration::from_secs(1), TcpStream::connect(addr))
@@ -19,13 +20,13 @@ pub async fn _ping_ip_2<T: ToSocketAddrs>(_addr: T) -> bool {
 }
 
 pub async fn _ping_ip_3<T: Into<IpAddr>>(addr: T) -> u8 {
-    match get_mac(Some(addr.into()), None, &[] as &[NUDState]).await {
+    match get_mac(Some(addr.into()), None, &[] as &[NeighborState]).await {
         Err(_) => 0,
         Ok(l) => l
             .into_iter()
             .map(|e| e.state)
             .max()
-            .map(NUDState::rank)
+            .map(NeighborState::rank)
             .unwrap_or_default(),
     }
 }

src/utils/query.rs

@@ -16,8 +16,7 @@ pub use macs::*;
 pub mod macs {
     use anyhow::Result;
     use std::net::IpAddr;
-
-    use crate::legacy::arpparse::{IpNeighLine, NUDState};
+    use wakey_core::{NeighborEntry, NeighborState};
 
     pub async fn get_ips(machine_name: &str) -> Result<impl Iterator<Item = IpAddr>> {
         wakey_linux::devices::get_ips(machine_name).await
@@ -27,17 +26,17 @@ pub mod macs {
         machine_names: &[impl AsRef<str>],
         ips: &[IpAddr],
         devs: &[impl AsRef<str>],
-        state: &[NUDState],
+        state: &[NeighborState],
         macs: &[macaddr::MacAddr],
-    ) -> Result<Vec<IpNeighLine>> {
+    ) -> Result<Vec<NeighborEntry>> {
         wakey_linux::devices::get_neighbors(machine_names, ips, devs, state, macs).await
     }
 
     pub async fn get_mac(
         ip: Option<IpAddr>,
         dev: Option<&str>,
-        state: &[NUDState],
-    ) -> Result<Vec<IpNeighLine>> {
+        state: &[NeighborState],
+    ) -> Result<Vec<NeighborEntry>> {
         let ips: Vec<IpAddr> = ip.into_iter().collect();
         let devs: Vec<&str> = dev.into_iter().collect();
         get_macs(&[] as &[&str], &ips, &devs, state, &[]).await