Fmt: Added cargofmt config and reformatted files

.rustfmt.toml

@@ -0,0 +1,2 @@
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"

google-home/src/device.rs

@@ -1,13 +1,11 @@
 use async_trait::async_trait;
 use serde::Serialize;
 
-use crate::{
-    errors::{DeviceError, ErrorCode},
-    request::execute::CommandType,
-    response,
-    traits::{FanSpeed, OnOff, Scene, Trait},
-    types::Type,
-};
+use crate::errors::{DeviceError, ErrorCode};
+use crate::request::execute::CommandType;
+use crate::response;
+use crate::traits::{FanSpeed, OnOff, Scene, Trait};
+use crate::types::Type;
 
 // TODO: Find a more elegant way to do this
 pub trait AsGoogleHomeDevice {

google-home/src/fullfillment.rs

@@ -1,15 +1,14 @@
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
+use std::sync::Arc;
 
 use futures::future::{join_all, OptionFuture};
 use thiserror::Error;
 use tokio::sync::{Mutex, RwLock};
 
-use crate::{
-    device::AsGoogleHomeDevice,
-    errors::{DeviceError, ErrorCode},
-    request::{self, Intent, Request},
-    response::{self, execute, query, sync, Response, ResponsePayload, State},
-};
+use crate::device::AsGoogleHomeDevice;
+use crate::errors::{DeviceError, ErrorCode};
+use crate::request::{self, Intent, Request};
+use crate::response::{self, execute, query, sync, Response, ResponsePayload, State};
 
 #[derive(Debug)]
 pub struct GoogleHome {

google-home/src/lib.rs

@@ -13,7 +13,6 @@ pub mod traits;
 pub mod types;
 
 pub use device::GoogleHomeDevice;
-pub use fullfillment::FullfillmentError;
-pub use fullfillment::GoogleHome;
+pub use fullfillment::{FullfillmentError, GoogleHome};
 pub use request::Request;
 pub use response::Response;

google-home/src/response/execute.rs

@@ -1,6 +1,7 @@
 use serde::Serialize;
 
-use crate::{errors::ErrorCode, response::State};
+use crate::errors::ErrorCode;
+use crate::response::State;
 
 #[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
@@ -87,10 +88,8 @@ pub enum Status {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        errors::DeviceError,
-        response::{Response, ResponsePayload, State},
-    };
+    use crate::errors::DeviceError;
+    use crate::response::{Response, ResponsePayload, State};
 
     #[test]
     fn serialize() {

google-home/src/response/query.rs

@@ -2,7 +2,8 @@ use std::collections::HashMap;
 
 use serde::Serialize;
 
-use crate::{errors::ErrorCode, response::State};
+use crate::errors::ErrorCode;
+use crate::response::State;
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]

google-home/src/response/sync.rs

@@ -69,11 +69,9 @@ impl Device {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        response::{Response, ResponsePayload},
-        traits::Trait,
-        types::Type,
-    };
+    use crate::response::{Response, ResponsePayload};
+    use crate::traits::Trait;
+    use crate::types::Type;
 
     #[test]
     fn serialize() {

impl_cast/src/lib.rs

@@ -1,6 +1,7 @@
 use proc_macro::TokenStream;
 use quote::{format_ident, quote, ToTokens};
-use syn::{parse::Parse, parse_macro_input, Ident, ItemTrait, Path, Token, TypeParamBound};
+use syn::parse::Parse;
+use syn::{parse_macro_input, Ident, ItemTrait, Path, Token, TypeParamBound};
 
 struct Attr {
     name: Ident,

src/auth.rs

@@ -1,8 +1,7 @@
-use axum::{
-    async_trait,
-    extract::{FromRef, FromRequestParts},
-    http::{request::Parts, StatusCode},
-};
+use axum::async_trait;
+use axum::extract::{FromRef, FromRequestParts};
+use axum::http::request::Parts;
+use axum::http::StatusCode;
 use serde::Deserialize;
 
 use crate::error::{ApiError, ApiErrorJson};

src/config.rs

@@ -1,8 +1,6 @@
-use std::{
-    fs,
-    net::{Ipv4Addr, SocketAddr},
-    time::Duration,
-};
+use std::fs;
+use std::net::{Ipv4Addr, SocketAddr};
+use std::time::Duration;
 
 use indexmap::IndexMap;
 use regex::{Captures, Regex};
@@ -10,13 +8,11 @@ use rumqttc::{MqttOptions, Transport};
 use serde::{Deserialize, Deserializer};
 use tracing::debug;
 
-use crate::{
-    auth::OpenIDConfig,
-    device_manager::DeviceConfigs,
-    devices::PresenceConfig,
-    error::{ConfigParseError, MissingEnv},
-    schedule::Schedule,
-};
+use crate::auth::OpenIDConfig;
+use crate::device_manager::DeviceConfigs;
+use crate::devices::PresenceConfig;
+use crate::error::{ConfigParseError, MissingEnv};
+use crate::schedule::Schedule;
 
 #[derive(Debug, Deserialize)]
 pub struct Config {

src/device_manager.rs

@@ -11,19 +11,14 @@ use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio_cron_scheduler::{Job, JobScheduler};
 use tracing::{debug, error, instrument, trace};
 
-use crate::{
-    devices::{
+use crate::devices::{
     AirFilterConfig, As, AudioSetupConfig, ContactSensorConfig, DebugBridgeConfig, Device,
     HueBridgeConfig, HueGroupConfig, IkeaOutletConfig, KasaOutletConfig, LightSensorConfig,
     WakeOnLANConfig, WasherConfig,
-    },
-    error::DeviceConfigError,
-    event::OnDarkness,
-    event::OnNotification,
-    event::OnPresence,
-    event::{Event, EventChannel, OnMqtt},
-    schedule::{Action, Schedule},
 };
+use crate::error::DeviceConfigError;
+use crate::event::{Event, EventChannel, OnDarkness, OnMqtt, OnNotification, OnPresence};
+use crate::schedule::{Action, Schedule};
 
 pub struct ConfigExternal<'a> {
     pub client: &'a AsyncClient,

src/devices/audio_setup.rs

@@ -3,17 +3,13 @@ use google_home::traits::OnOff;
 use serde::Deserialize;
 use tracing::{debug, error, trace, warn};
 
-use crate::{
-    config::MqttDeviceConfig,
-    device_manager::{ConfigExternal, DeviceConfig, WrappedDevice},
-    devices::As,
-    error::DeviceConfigError,
-    event::OnMqtt,
-    event::OnPresence,
-    messages::{RemoteAction, RemoteMessage},
-};
-
 use super::Device;
+use crate::config::MqttDeviceConfig;
+use crate::device_manager::{ConfigExternal, DeviceConfig, WrappedDevice};
+use crate::devices::As;
+use crate::error::DeviceConfigError;
+use crate::event::{OnMqtt, OnPresence};
+use crate::messages::{RemoteAction, RemoteMessage};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct AudioSetupConfig {

src/devices/contact_sensor.rs

@@ -8,18 +8,14 @@ use serde_with::{serde_as, DurationSeconds};
 use tokio::task::JoinHandle;
 use tracing::{debug, error, trace, warn};
 
-use crate::{
-    config::MqttDeviceConfig,
-    device_manager::{ConfigExternal, DeviceConfig, WrappedDevice},
-    devices::{As, DEFAULT_PRESENCE},
-    error::DeviceConfigError,
-    event::OnMqtt,
-    event::OnPresence,
-    messages::{ContactMessage, PresenceMessage},
-    traits::Timeout,
-};
-
 use super::Device;
+use crate::config::MqttDeviceConfig;
+use crate::device_manager::{ConfigExternal, DeviceConfig, WrappedDevice};
+use crate::devices::{As, DEFAULT_PRESENCE};
+use crate::error::DeviceConfigError;
+use crate::event::{OnMqtt, OnPresence};
+use crate::messages::{ContactMessage, PresenceMessage};
+use crate::traits::Timeout;
 
 // NOTE: If we add more presence devices we might need to move this out of here
 #[serde_as]

src/devices/debug_bridge.rs

@@ -3,16 +3,12 @@ use rumqttc::AsyncClient;
 use serde::Deserialize;
 use tracing::warn;
 
-use crate::device_manager::ConfigExternal;
-use crate::device_manager::DeviceConfig;
+use crate::config::MqttDeviceConfig;
+use crate::device_manager::{ConfigExternal, DeviceConfig};
 use crate::devices::Device;
 use crate::error::DeviceConfigError;
-use crate::event::OnDarkness;
-use crate::event::OnPresence;
-use crate::{
-    config::MqttDeviceConfig,
-    messages::{DarknessMessage, PresenceMessage},
-};
+use crate::event::{OnDarkness, OnPresence};
+use crate::messages::{DarknessMessage, PresenceMessage};
 
 #[derive(Debug, Deserialize)]
 pub struct DebugBridgeConfig {

src/devices/hue_bridge.rs

@@ -4,13 +4,10 @@ use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use tracing::{error, trace, warn};
 
-use crate::{
-    device_manager::{ConfigExternal, DeviceConfig},
-    devices::Device,
-    error::DeviceConfigError,
-    event::OnDarkness,
-    event::OnPresence,
-};
+use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::devices::Device;
+use crate::error::DeviceConfigError;
+use crate::event::{OnDarkness, OnPresence};
 
 #[derive(Debug)]
 pub enum Flag {

src/devices/hue_light.rs

@@ -1,25 +1,21 @@
-use std::{
-    net::{Ipv4Addr, SocketAddr},
-    time::Duration,
-};
+use std::net::{Ipv4Addr, SocketAddr};
+use std::time::Duration;
 
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
-use google_home::{errors::ErrorCode, traits::OnOff};
+use google_home::errors::ErrorCode;
+use google_home::traits::OnOff;
 use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, error, warn};
 
-use crate::{
-    config::MqttDeviceConfig,
-    device_manager::{ConfigExternal, DeviceConfig},
-    error::DeviceConfigError,
-    event::OnMqtt,
-    messages::{RemoteAction, RemoteMessage},
-    traits::Timeout,
-};
-
 use super::Device;
+use crate::config::MqttDeviceConfig;
+use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::error::DeviceConfigError;
+use crate::event::OnMqtt;
+use crate::messages::{RemoteAction, RemoteMessage};
+use crate::traits::Timeout;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct HueGroupConfig {
@@ -229,7 +225,8 @@ impl Timeout for HueGroup {
 mod message {
     use std::time::Duration;
 
-    use serde::{ser::SerializeStruct, Deserialize, Serialize};
+    use serde::ser::SerializeStruct;
+    use serde::{Deserialize, Serialize};
 
     #[derive(Debug, Serialize, Deserialize)]
     pub struct Action {

src/devices/ikea_outlet.rs

@@ -1,17 +1,14 @@
+use std::time::Duration;
+
 use anyhow::Result;
 use async_trait::async_trait;
 use google_home::errors::ErrorCode;
-use google_home::{
-    device,
-    traits::{self, OnOff},
-    types::Type,
-    GoogleHomeDevice,
-};
+use google_home::traits::{self, OnOff};
+use google_home::types::Type;
+use google_home::{device, GoogleHomeDevice};
 use rumqttc::{matches, AsyncClient, Publish};
 use serde::Deserialize;
-use serde_with::serde_as;
-use serde_with::DurationSeconds;
-use std::time::Duration;
+use serde_with::{serde_as, DurationSeconds};
 use tokio::task::JoinHandle;
 use tracing::{debug, error, trace, warn};
 
@@ -19,8 +16,7 @@ use crate::config::{InfoConfig, MqttDeviceConfig};
 use crate::device_manager::{ConfigExternal, DeviceConfig};
 use crate::devices::Device;
 use crate::error::DeviceConfigError;
-use crate::event::OnMqtt;
-use crate::event::OnPresence;
+use crate::event::{OnMqtt, OnPresence};
 use crate::messages::{OnOffMessage, RemoteAction, RemoteMessage};
 use crate::traits::Timeout;
 

src/devices/kasa_outlet.rs

@@ -1,28 +1,19 @@
-use std::{
-    net::{Ipv4Addr, SocketAddr},
-    str::Utf8Error,
-};
+use std::net::{Ipv4Addr, SocketAddr};
+use std::str::Utf8Error;
 
 use async_trait::async_trait;
 use bytes::{Buf, BufMut};
-use google_home::{
-    errors::{self, DeviceError},
-    traits,
-};
+use google_home::errors::{self, DeviceError};
+use google_home::traits;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    net::TcpStream,
-};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
 use tracing::trace;
 
-use crate::{
-    device_manager::{ConfigExternal, DeviceConfig},
-    error::DeviceConfigError,
-};
-
 use super::Device;
+use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::error::DeviceConfigError;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct KasaOutletConfig {

src/devices/light_sensor.rs

@@ -3,15 +3,12 @@ use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, trace, warn};
 
-use crate::{
-    config::MqttDeviceConfig,
-    device_manager::{ConfigExternal, DeviceConfig},
-    devices::Device,
-    error::DeviceConfigError,
-    event::OnMqtt,
-    event::{self, Event},
-    messages::BrightnessMessage,
-};
+use crate::config::MqttDeviceConfig;
+use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::devices::Device;
+use crate::error::DeviceConfigError;
+use crate::event::{self, Event, OnMqtt};
+use crate::messages::BrightnessMessage;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct LightSensorConfig {

src/devices/mod.rs

@@ -12,6 +12,9 @@ mod presence;
 mod wake_on_lan;
 mod washer;
 
+use google_home::device::AsGoogleHomeDevice;
+use google_home::traits::OnOff;
+
 pub use self::air_filter::AirFilterConfig;
 pub use self::audio_setup::AudioSetupConfig;
 pub use self::contact_sensor::ContactSensorConfig;
@@ -25,11 +28,8 @@ pub use self::ntfy::{Notification, Ntfy};
 pub use self::presence::{Presence, PresenceConfig, DEFAULT_PRESENCE};
 pub use self::wake_on_lan::WakeOnLANConfig;
 pub use self::washer::WasherConfig;
-
-use google_home::{device::AsGoogleHomeDevice, traits::OnOff};
-
+use crate::event::{OnDarkness, OnMqtt, OnNotification, OnPresence};
 use crate::traits::Timeout;
-use crate::{event::OnDarkness, event::OnMqtt, event::OnNotification, event::OnPresence};
 
 #[impl_cast::device(As: OnMqtt + OnPresence + OnDarkness + OnNotification + OnOff + Timeout)]
 pub trait Device: AsGoogleHomeDevice + std::fmt::Debug + Sync + Send {

src/devices/ntfy.rs

@@ -5,12 +5,9 @@ use serde::Serialize;
 use serde_repr::*;
 use tracing::{debug, error, warn};
 
-use crate::{
-    config::NtfyConfig,
-    devices::Device,
-    event::{self, Event, EventChannel},
-    event::{OnNotification, OnPresence},
-};
+use crate::config::NtfyConfig;
+use crate::devices::Device;
+use crate::event::{self, Event, EventChannel, OnNotification, OnPresence};
 
 #[derive(Debug)]
 pub struct Ntfy {

src/devices/presence.rs

@@ -5,13 +5,10 @@ use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, warn};
 
-use crate::{
-    config::MqttDeviceConfig,
-    devices::Device,
-    event::OnMqtt,
-    event::{self, Event, EventChannel},
-    messages::PresenceMessage,
-};
+use crate::config::MqttDeviceConfig;
+use crate::devices::Device;
+use crate::event::{self, Event, EventChannel, OnMqtt};
+use crate::messages::PresenceMessage;
 
 #[derive(Debug, Deserialize)]
 pub struct PresenceConfig {

src/devices/wake_on_lan.rs

@@ -2,26 +2,20 @@ use std::net::Ipv4Addr;
 
 use async_trait::async_trait;
 use eui48::MacAddress;
-use google_home::{
-    device,
-    errors::ErrorCode,
-    traits::{self, Scene},
-    types::Type,
-    GoogleHomeDevice,
-};
+use google_home::errors::ErrorCode;
+use google_home::traits::{self, Scene};
+use google_home::types::Type;
+use google_home::{device, GoogleHomeDevice};
 use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, error, trace};
 
-use crate::{
-    config::{InfoConfig, MqttDeviceConfig},
-    device_manager::{ConfigExternal, DeviceConfig},
-    error::DeviceConfigError,
-    event::OnMqtt,
-    messages::ActivateMessage,
-};
-
 use super::Device;
+use crate::config::{InfoConfig, MqttDeviceConfig};
+use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::error::DeviceConfigError;
+use crate::event::OnMqtt;
+use crate::messages::ActivateMessage;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct WakeOnLANConfig {

src/devices/washer.rs

@@ -3,15 +3,13 @@ use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, error, warn};
 
-use crate::{
-    config::MqttDeviceConfig,
-    device_manager::{ConfigExternal, DeviceConfig},
-    error::DeviceConfigError,
-    event::{Event, EventChannel, OnMqtt},
-    messages::PowerMessage,
-};
-
-use super::{ntfy::Priority, Device, Notification};
+use super::ntfy::Priority;
+use super::{Device, Notification};
+use crate::config::MqttDeviceConfig;
+use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::error::DeviceConfigError;
+use crate::event::{Event, EventChannel, OnMqtt};
+use crate::messages::PowerMessage;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct WasherConfig {

src/error.rs

@@ -1,6 +1,7 @@
 use std::{error, fmt, result};
 
-use axum::{http::status::InvalidStatusCode, response::IntoResponse};
+use axum::http::status::InvalidStatusCode;
+use axum::response::IntoResponse;
 use bytes::Bytes;
 use rumqttc::ClientError;
 use serde::{Deserialize, Serialize};

src/event.rs

@@ -1,9 +1,8 @@
 use async_trait::async_trait;
+use impl_cast::device_trait;
 use rumqttc::Publish;
 use tokio::sync::mpsc;
 
-use impl_cast::device_trait;
-
 use crate::devices::Notification;
 
 #[derive(Debug, Clone)]

src/main.rs

@@ -1,23 +1,22 @@
 #![feature(async_closure)]
 use std::process;
 
-use axum::{
-    extract::FromRef, http::StatusCode, response::IntoResponse, routing::post, Json, Router,
-};
+use automation::auth::{OpenIDConfig, User};
+use automation::config::Config;
+use automation::device_manager::DeviceManager;
+use automation::devices::{Ntfy, Presence};
+use automation::error::ApiError;
+use automation::mqtt;
+use axum::extract::FromRef;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::routing::post;
+use axum::{Json, Router};
 use dotenvy::dotenv;
+use google_home::{GoogleHome, Request};
 use rumqttc::AsyncClient;
 use tracing::{debug, error, info};
 
-use automation::{
-    auth::{OpenIDConfig, User},
-    config::Config,
-    device_manager::DeviceManager,
-    devices::{Ntfy, Presence},
-    error::ApiError,
-    mqtt,
-};
-use google_home::{GoogleHome, Request};
-
 #[derive(Clone)]
 struct AppState {
     pub openid: OpenIDConfig,

src/mqtt.rs

@@ -1,6 +1,5 @@
-use tracing::{debug, warn};
-
 use rumqttc::{Event, EventLoop, Incoming};
+use tracing::{debug, warn};
 
 use crate::event::{self, EventChannel};