Applied rust fmt

google-home/src/device.rs

@@ -1,6 +1,12 @@
 use serde::Serialize;
 
-use crate::{response, types::Type, traits::{AsOnOff, Trait, AsScene}, errors::{DeviceError, ErrorCode}, request::execute::CommandType};
+use crate::{
+    errors::{DeviceError, ErrorCode},
+    request::execute::CommandType,
+    response,
+    traits::{AsOnOff, AsScene, Trait},
+    types::Type,
+};
 
 pub trait GoogleHomeDevice: AsOnOff + AsScene {
     fn get_device_type(&self) -> Type;
@@ -19,11 +25,10 @@ pub trait GoogleHomeDevice: AsOnOff + AsScene {
         None
     }
 
-
-
     fn sync(&self) -> response::sync::Device {
         let name = self.get_device_name();
-        let mut device = response::sync::Device::new(self.get_id(), &name.name, self.get_device_type());
+        let mut device =
+            response::sync::Device::new(self.get_id(), &name.name, self.get_device_type());
 
         device.name = name;
         device.will_report_state = self.will_report_state();
@@ -60,9 +65,7 @@ pub trait GoogleHomeDevice: AsOnOff + AsScene {
 
         // OnOff
         if let Some(on_off) = AsOnOff::cast(self) {
-            device.state.on = on_off.is_on()
-                .map_err(|err| device.set_error(err))
-                .ok();
+            device.state.on = on_off.is_on().map_err(|err| device.set_error(err)).ok();
         }
 
         device
@@ -75,13 +78,13 @@ pub trait GoogleHomeDevice: AsOnOff + AsScene {
                     .ok_or::<ErrorCode>(DeviceError::ActionNotAvailable.into())?;
 
                 on_off.set_on(*on)?;
-            },
+            }
             CommandType::ActivateScene { deactivate } => {
                 let scene = AsScene::cast_mut(self)
                     .ok_or::<ErrorCode>(DeviceError::ActionNotAvailable.into())?;
 
                 scene.set_active(!deactivate)?;
-            },
+            }
         }
 
         Ok(())
@@ -100,7 +103,11 @@ pub struct Name {
 
 impl Name {
     pub fn new(name: &str) -> Self {
-        Self { default_names: Vec::new(), name: name.into(), nicknames: Vec::new() }
+        Self {
+            default_names: Vec::new(),
+            name: name.into(),
+            nicknames: Vec::new(),
+        }
     }
 
     pub fn add_default_name(&mut self, name: &str) {

google-home/src/errors.rs

@@ -1,5 +1,5 @@
-use thiserror::Error;
 use serde::Serialize;
+use thiserror::Error;
 
 #[derive(Debug, Hash, PartialEq, Eq, Copy, Clone, Serialize, Error)]
 #[serde(rename_all = "camelCase")]
@@ -16,8 +16,7 @@ pub enum DeviceError {
 
 #[derive(Debug, Hash, PartialEq, Eq, Copy, Clone, Serialize, Error)]
 #[serde(rename_all = "camelCase")]
-pub enum DeviceException {
-}
+pub enum DeviceException {}
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy, Serialize, Error)]
 #[serde(untagged)]

google-home/src/fullfillment.rs

@@ -2,7 +2,12 @@ use std::collections::HashMap;
 
 use thiserror::Error;
 
-use crate::{request::{Request, Intent, self}, device::GoogleHomeDevice, response::{sync, ResponsePayload, query, execute, Response, self, State}, errors::{DeviceError, ErrorCode}};
+use crate::{
+    device::GoogleHomeDevice,
+    errors::{DeviceError, ErrorCode},
+    request::{self, Intent, Request},
+    response::{self, execute, query, sync, Response, ResponsePayload, State},
+};
 
 #[derive(Debug)]
 pub struct GoogleHome {
@@ -13,15 +18,21 @@ pub struct GoogleHome {
 #[derive(Debug, Error)]
 pub enum FullfillmentError {
     #[error("Expected at least one ResponsePayload")]
-    ExpectedOnePayload
+    ExpectedOnePayload,
 }
 
 impl GoogleHome {
     pub fn new(user_id: &str) -> Self {
-        Self { user_id: user_id.into() }
+        Self {
+            user_id: user_id.into(),
+        }
     }
 
-    pub fn handle_request(&self, request: Request, devices: &mut HashMap<&str, &mut dyn GoogleHomeDevice>) -> Result<Response, FullfillmentError> {
+    pub fn handle_request(
+        &self,
+        request: Request,
+        devices: &mut HashMap<&str, &mut dyn GoogleHomeDevice>,
+    ) -> Result<Response, FullfillmentError> {
         // TODO: What do we do if we actually get more then one thing in the input array, right now
         // we only respond to the first thing
         let payload = request
@@ -30,8 +41,11 @@ impl GoogleHome {
             .map(|input| match input {
                 Intent::Sync => ResponsePayload::Sync(self.sync(devices)),
                 Intent::Query(payload) => ResponsePayload::Query(self.query(payload, devices)),
-                Intent::Execute(payload) => ResponsePayload::Execute(self.execute(payload, devices)),
-            }).next();
+                Intent::Execute(payload) => {
+                    ResponsePayload::Execute(self.execute(payload, devices))
+                }
+            })
+            .next();
 
         payload
             .ok_or(FullfillmentError::ExpectedOnePayload)
@@ -48,83 +62,111 @@ impl GoogleHome {
         resp_payload
     }
 
-    fn query(&self, payload: request::query::Payload, devices: &HashMap<&str, &mut dyn GoogleHomeDevice>) -> query::Payload {
+    fn query(
+        &self,
+        payload: request::query::Payload,
+        devices: &HashMap<&str, &mut dyn GoogleHomeDevice>,
+    ) -> query::Payload {
         let mut resp_payload = query::Payload::new();
-        resp_payload.devices = payload.devices
+        resp_payload.devices = payload
+            .devices
             .into_iter()
             .map(|device| device.id)
             .map(|id| {
-                let device = devices.get(id.as_str())
-                    .map_or_else(|| {
+                let device = devices.get(id.as_str()).map_or_else(
+                    || {
                         let mut device = query::Device::new();
                         device.set_offline();
                         device.set_error(DeviceError::DeviceNotFound.into());
 
                         device
-                    }, |device| device.query());
+                    },
+                    |device| device.query(),
+                );
 
                 (id, device)
-            }).collect();
+            })
+            .collect();
 
         resp_payload
-
     }
 
-    fn execute(&self, payload: request::execute::Payload, devices: &mut HashMap<&str, &mut dyn GoogleHomeDevice>) -> execute::Payload {
+    fn execute(
+        &self,
+        payload: request::execute::Payload,
+        devices: &mut HashMap<&str, &mut dyn GoogleHomeDevice>,
+    ) -> execute::Payload {
         let mut resp_payload = response::execute::Payload::new();
 
-        payload.commands
-            .into_iter()
-            .for_each(|command| {
-                let mut success = response::execute::Command::new(execute::Status::Success);
-                success.states = Some(execute::States { online: true, state: State::default() });
-                let mut offline = response::execute::Command::new(execute::Status::Offline);
-                offline.states = Some(execute::States { online: false, state: State::default() });
-                let mut errors: HashMap<ErrorCode, response::execute::Command> = HashMap::new();
+        payload.commands.into_iter().for_each(|command| {
+            let mut success = response::execute::Command::new(execute::Status::Success);
+            success.states = Some(execute::States {
+                online: true,
+                state: State::default(),
+            });
+            let mut offline = response::execute::Command::new(execute::Status::Offline);
+            offline.states = Some(execute::States {
+                online: false,
+                state: State::default(),
+            });
+            let mut errors: HashMap<ErrorCode, response::execute::Command> = HashMap::new();
 
-                command.devices
-                    .into_iter()
-                    .map(|device| device.id)
-                    .map(|id| {
-                        devices.get_mut(id.as_str())
-                            .map_or((id.clone(), Err(DeviceError::DeviceNotFound.into())), |device| {
-                                if !device.is_online() {
-                                    return (id, Ok(false));
-                                }
+            command
+                .devices
+                .into_iter()
+                .map(|device| device.id)
+                .map(|id| {
+                    devices.get_mut(id.as_str()).map_or(
+                        (id.clone(), Err(DeviceError::DeviceNotFound.into())),
+                        |device| {
+                            if !device.is_online() {
+                                return (id, Ok(false));
+                            }
 
-                                let results = command.execution.iter().map(|cmd| {
+                            let results = command
+                                .execution
+                                .iter()
+                                .map(|cmd| {
                                     // TODO: We should also return the state after update in the state
                                     // struct, however that will make things WAY more complicated
                                     device.execute(cmd)
-                                }).collect::<Result<Vec<_>, ErrorCode>>();
+                                })
+                                .collect::<Result<Vec<_>, ErrorCode>>();
 
-                                // TODO: We only get one error not all errors
-                                if let Err(err) = results {
-                                    (id, Err(err))
-                                } else {
-                                    (id, Ok(true))
+                            // TODO: We only get one error not all errors
+                            if let Err(err) = results {
+                                (id, Err(err))
+                            } else {
+                                (id, Ok(true))
+                            }
+                        },
+                    )
+                })
+                .for_each(|(id, state)| {
+                    match state {
+                        Ok(true) => success.add_id(&id),
+                        Ok(false) => offline.add_id(&id),
+                        Err(err) => errors
+                            .entry(err)
+                            .or_insert_with(|| match &err {
+                                ErrorCode::DeviceError(_) => {
+                                    response::execute::Command::new(execute::Status::Error)
+                                }
+                                ErrorCode::DeviceException(_) => {
+                                    response::execute::Command::new(execute::Status::Exceptions)
                                 }
                             })
-                    }).for_each(|(id, state)| {
-                        match state {
-                            Ok(true) => success.add_id(&id),
-                            Ok(false) => offline.add_id(&id),
-                            Err(err) => errors.entry(err).or_insert_with(|| {
-                                match &err {
-                                    ErrorCode::DeviceError(_) => response::execute::Command::new(execute::Status::Error),
-                                    ErrorCode::DeviceException(_) => response::execute::Command::new(execute::Status::Exceptions),
-                                }
-                            }).add_id(&id),
-                        };
-                    });
+                            .add_id(&id),
+                    };
+                });
 
-                resp_payload.add_command(success);
-                resp_payload.add_command(offline);
-                for (error, mut cmd) in errors {
-                    cmd.error_code = Some(error);
-                    resp_payload.add_command(cmd);
-                }
-            });
+            resp_payload.add_command(success);
+            resp_payload.add_command(offline);
+            for (error, mut cmd) in errors {
+                cmd.error_code = Some(error);
+                resp_payload.add_command(cmd);
+            }
+        });
 
         resp_payload
     }
@@ -133,7 +175,12 @@ impl GoogleHome {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{request::Request, device::{GoogleHomeDevice, self}, types, traits, errors::ErrorCode};
+    use crate::{
+        device::{self, GoogleHomeDevice},
+        errors::ErrorCode,
+        request::Request,
+        traits, types,
+    };
 
     #[derive(Debug)]
     struct TestOutlet {
@@ -143,7 +190,10 @@ mod tests {
 
     impl TestOutlet {
         fn new(name: &str) -> Self {
-            Self { name: name.into(), on: false }
+            Self {
+                name: name.into(),
+                on: false,
+            }
         }
     }
 

google-home/src/lib.rs

@@ -1,18 +1,18 @@
 #![allow(incomplete_features)]
 #![feature(specialization)]
-mod fullfillment;
 pub mod device;
+mod fullfillment;
 
 mod request;
 mod response;
 
-pub mod types;
-pub mod traits;
-pub mod errors;
 mod attributes;
+pub mod errors;
+pub mod traits;
+pub mod types;
 
-pub use fullfillment::GoogleHome;
+pub use device::GoogleHomeDevice;
 pub use fullfillment::FullfillmentError;
+pub use fullfillment::GoogleHome;
 pub use request::Request;
 pub use response::Response;
-pub use device::GoogleHomeDevice;

google-home/src/request.rs

@@ -1,6 +1,6 @@
-pub mod sync;
-pub mod query;
 pub mod execute;
+pub mod query;
+pub mod sync;
 
 use serde::Deserialize;
 

google-home/src/request/execute.rs

@@ -10,7 +10,7 @@ pub struct Payload {
 #[serde(rename_all = "camelCase")]
 pub struct Command {
     pub devices: Vec<Device>,
-    pub execution: Vec<CommandType>
+    pub execution: Vec<CommandType>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -24,23 +24,18 @@ pub struct Device {
 #[serde(tag = "command", content = "params")]
 pub enum CommandType {
     #[serde(rename = "action.devices.commands.OnOff")]
-    OnOff {
-        on: bool
-    },
+    OnOff { on: bool },
     #[serde(rename = "action.devices.commands.ActivateScene")]
-    ActivateScene {
-        deactivate: bool
-    }
+    ActivateScene { deactivate: bool },
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::request::{Request, Intent};
+    use crate::request::{Intent, Request};
 
     #[test]
     fn deserialize() {
-
         let json = r#"{
   "requestId": "ff36a3cc-ec34-11e6-b1a0-64510650abcf",
   "inputs": [
@@ -86,7 +81,10 @@ mod tests {
 
         println!("{:?}", req);
 
-        assert_eq!(req.request_id, "ff36a3cc-ec34-11e6-b1a0-64510650abcf".to_owned());
+        assert_eq!(
+            req.request_id,
+            "ff36a3cc-ec34-11e6-b1a0-64510650abcf".to_owned()
+        );
         assert_eq!(req.inputs.len(), 1);
         match &req.inputs[0] {
             Intent::Execute(payload) => {
@@ -96,11 +94,11 @@ mod tests {
                 assert_eq!(payload.commands[0].devices[1].id, "456");
                 assert_eq!(payload.commands[0].execution.len(), 1);
                 match payload.commands[0].execution[0] {
-                    CommandType::OnOff{on} => assert!(on),
-                    _ => panic!("Expected OnOff")
+                    CommandType::OnOff { on } => assert!(on),
+                    _ => panic!("Expected OnOff"),
                 }
-            },
-            _ => panic!("Expected Execute intent")
+            }
+            _ => panic!("Expected Execute intent"),
         };
     }
 }

google-home/src/request/query.rs

@@ -15,11 +15,10 @@ pub struct Device {
 
 #[cfg(test)]
 mod tests {
-    use crate::request::{Request, Intent};
+    use crate::request::{Intent, Request};
 
     #[test]
     fn deserialize() {
-
         let json = r#"{
   "requestId": "ff36a3cc-ec34-11e6-b1a0-64510650abcf",
   "inputs": [
@@ -53,15 +52,18 @@ mod tests {
 
         println!("{:?}", req);
 
-        assert_eq!(req.request_id, "ff36a3cc-ec34-11e6-b1a0-64510650abcf".to_owned());
+        assert_eq!(
+            req.request_id,
+            "ff36a3cc-ec34-11e6-b1a0-64510650abcf".to_owned()
+        );
         assert_eq!(req.inputs.len(), 1);
         match &req.inputs[0] {
             Intent::Query(payload) => {
                 assert_eq!(payload.devices.len(), 2);
                 assert_eq!(payload.devices[0].id, "123");
                 assert_eq!(payload.devices[1].id, "456");
-            },
-            _ => panic!("Expected Query intent")
+            }
+            _ => panic!("Expected Query intent"),
         };
     }
 }

google-home/src/request/sync.rs

@@ -1,10 +1,9 @@
 #[cfg(test)]
 mod tests {
-    use crate::request::{Request, Intent};
+    use crate::request::{Intent, Request};
 
     #[test]
     fn deserialize() {
-
         let json = r#"{
       "requestId": "ff36a3cc-ec34-11e6-b1a0-64510650abcf",
       "inputs": [
@@ -18,12 +17,14 @@ mod tests {
 
         println!("{:?}", req);
 
-        assert_eq!(req.request_id, "ff36a3cc-ec34-11e6-b1a0-64510650abcf".to_owned());
+        assert_eq!(
+            req.request_id,
+            "ff36a3cc-ec34-11e6-b1a0-64510650abcf".to_owned()
+        );
         assert_eq!(req.inputs.len(), 1);
         match req.inputs[0] {
-            Intent::Sync => {},
-            _ => panic!("Expected Sync intent")
+            Intent::Sync => {}
+            _ => panic!("Expected Sync intent"),
         }
     }
 }
-

google-home/src/response.rs

@@ -1,6 +1,6 @@
-pub mod sync;
-pub mod query;
 pub mod execute;
+pub mod query;
+pub mod sync;
 
 use serde::Serialize;
 
@@ -13,7 +13,10 @@ pub struct Response {
 
 impl Response {
     pub fn new(request_id: &str, payload: ResponsePayload) -> Self {
-        Self { request_id: request_id.to_owned(), payload }
+        Self {
+            request_id: request_id.to_owned(),
+            payload,
+        }
     }
 }
 

google-home/src/response/execute.rs

@@ -1,6 +1,6 @@
 use serde::Serialize;
 
-use crate::{response::State, errors::ErrorCode};
+use crate::{errors::ErrorCode, response::State};
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -14,7 +14,11 @@ pub struct Payload {
 
 impl Payload {
     pub fn new() -> Self {
-        Self { error_code: None, debug_string: None, commands: Vec::new() }
+        Self {
+            error_code: None,
+            debug_string: None,
+            commands: Vec::new(),
+        }
     }
 
     pub fn add_command(&mut self, command: Command) {
@@ -44,7 +48,12 @@ pub struct Command {
 
 impl Command {
     pub fn new(status: Status) -> Self {
-        Self { error_code: None, ids: Vec::new(), status, states: None }
+        Self {
+            error_code: None,
+            ids: Vec::new(),
+            status,
+            states: None,
+        }
     }
 
     pub fn add_id(&mut self, id: &str) {
@@ -78,7 +87,10 @@ pub enum Status {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{response::{Response, ResponsePayload, State}, errors::DeviceError};
+    use crate::{
+        errors::DeviceError,
+        response::{Response, ResponsePayload, State},
+    };
 
     #[test]
     fn serialize() {
@@ -98,7 +110,10 @@ mod tests {
         command.ids.push("456".into());
         execute_resp.add_command(command);
 
-        let resp = Response::new("ff36a3cc-ec34-11e6-b1a0-64510650abcf", ResponsePayload::Execute(execute_resp));
+        let resp = Response::new(
+            "ff36a3cc-ec34-11e6-b1a0-64510650abcf",
+            ResponsePayload::Execute(execute_resp),
+        );
 
         let json = serde_json::to_string(&resp).unwrap();
 

google-home/src/response/query.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use serde::Serialize;
 
-use crate::{response::State, errors::ErrorCode};
+use crate::{errors::ErrorCode, response::State};
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -16,7 +16,11 @@ pub struct Payload {
 
 impl Payload {
     pub fn new() -> Self {
-        Self { error_code: None, debug_string: None, devices: HashMap::new() }
+        Self {
+            error_code: None,
+            debug_string: None,
+            devices: HashMap::new(),
+        }
     }
 
     pub fn add_device(&mut self, id: &str, device: Device) {
@@ -53,7 +57,12 @@ pub struct Device {
 
 impl Device {
     pub fn new() -> Self {
-        Self { online: true, status: Status::Success, error_code: None, state: State::default() }
+        Self {
+            online: true,
+            status: Status::Success,
+            error_code: None,
+            state: State::default(),
+        }
     }
 
     pub fn set_offline(&mut self) {
@@ -93,7 +102,10 @@ mod tests {
         device.state.on = Some(false);
         query_resp.add_device("456", device);
 
-        let resp = Response::new("ff36a3cc-ec34-11e6-b1a0-64510650abcf", ResponsePayload::Query(query_resp));
+        let resp = Response::new(
+            "ff36a3cc-ec34-11e6-b1a0-64510650abcf",
+            ResponsePayload::Query(query_resp),
+        );
 
         let json = serde_json::to_string(&resp).unwrap();
 

google-home/src/response/sync.rs

@@ -3,8 +3,8 @@ use serde::Serialize;
 use crate::attributes::Attributes;
 use crate::device;
 use crate::errors::ErrorCode;
-use crate::types::Type;
 use crate::traits::Trait;
+use crate::types::Type;
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -19,7 +19,12 @@ pub struct Payload {
 
 impl Payload {
     pub fn new(agent_user_id: &str) -> Self {
-        Self { agent_user_id: agent_user_id.into(), error_code: None, debug_string: None, devices: Vec::new() }
+        Self {
+            agent_user_id: agent_user_id.into(),
+            error_code: None,
+            debug_string: None,
+            devices: Vec::new(),
+        }
     }
 
     pub fn add_device(&mut self, device: Device) {
@@ -64,7 +69,11 @@ impl Device {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{response::{Response, ResponsePayload}, types::Type, traits::Trait};
+    use crate::{
+        response::{Response, ResponsePayload},
+        traits::Trait,
+        types::Type,
+    };
 
     #[test]
     fn serialize() {
@@ -85,7 +94,10 @@ mod tests {
 
         sync_resp.add_device(device);
 
-        let resp = Response::new("ff36a3cc-ec34-11e6-b1a0-64510650abcf", ResponsePayload::Sync(sync_resp));
+        let resp = Response::new(
+            "ff36a3cc-ec34-11e6-b1a0-64510650abcf",
+            ResponsePayload::Sync(sync_resp),
+        );
 
         let json = serde_json::to_string(&resp).unwrap();