improv: Refactor daemon code using macro to reduce redundance

Macro magic like this is potentially confusing, but arguably it's no
less confusing to have to manually add each new method in various
places. Now it only has to be added to the commands! call, and the
server.

So dark sorcery, but it should be easier to work with ultimately. (Hail
Cthulhu!)

Author: ids1024

src/daemon/client.rs

@@ -1,4 +1,3 @@
-use serde::de::DeserializeOwned;
 use std::{
     io::{
         BufRead,
@@ -8,12 +7,11 @@ use std::{
     },
 };
 
-use crate::color::Rgb;
 use super::{
     err_str,
-    Daemon,
+    DaemonClientTrait,
     DaemonCommand,
-    DaemonResult,
+    DaemonResponse,
 };
 
 pub struct DaemonClient<R: Read, W: Write> {
@@ -28,60 +26,22 @@ impl<R: Read, W: Write> DaemonClient<R, W> {
             write,
         }
     }
+}
 
-    fn command<T: DeserializeOwned>(&mut self, command: DaemonCommand) -> Result<T, String> {
+impl<R: std::io::Read, W: std::io::Write> DaemonClientTrait for DaemonClient<R, W> {
+    fn send_command(&mut self, command: DaemonCommand) -> Result<DaemonResponse, String> {
         let mut command_json = serde_json::to_string(&command).map_err(err_str)?;
         command_json.push('\n');
         self.write.write_all(command_json.as_bytes()).map_err(err_str)?;
 
-        let mut result_json = String::new();
-        self.read.read_line(&mut result_json).map_err(err_str)?;
-        let result = serde_json::from_str::<DaemonResult>(&result_json).map_err(err_str)?;
-        match result {
-            DaemonResult::Ok { ok } => {
-                serde_json::from_reader(ok.as_bytes()).map_err(err_str)
-            },
-            DaemonResult::Err { err } => Err(err),
-        }
-    }
-}
-
-impl<R: Read, W: Write> Daemon for DaemonClient<R, W> {
-    fn boards(&mut self) -> Result<Vec<String>, String> {
-        self.command(DaemonCommand::Boards)
-    }
-
-    fn keymap_get(&mut self, board: usize, layer: u8, output: u8, input: u8) -> Result<u16, String> {
-        self.command(DaemonCommand::KeymapGet { board, layer, output, input })
-    }
-
-    fn keymap_set(&mut self, board: usize, layer: u8, output: u8, input: u8, value: u16) -> Result<(), String> {
-        self.command(DaemonCommand::KeymapSet { board, layer, output, input, value })
-    }
-
-    fn color(&mut self) -> Result<Rgb, String> {
-        self.command(DaemonCommand::Color)
-    }
-
-    fn set_color(&mut self, color: Rgb) -> Result<(), String> {
-        self.command(DaemonCommand::SetColor { color })
-    }
-
-    fn max_brightness(&mut self) -> Result<i32, String> {
-        self.command(DaemonCommand::MaxBrightness)
-    }
-
-    fn brightness(&mut self) -> Result<i32, String> {
-        self.command(DaemonCommand::Brightness)
-    }
-
-    fn set_brightness(&mut self, brightness: i32) -> Result<(), String> {
-        self.command(DaemonCommand::SetBrightness { brightness })
+        let mut response_json = String::new();
+        self.read.read_line(&mut response_json).map_err(err_str)?;
+        serde_json::from_str(&response_json).map_err(err_str)?
     }
 }
 
 impl<R: Read, W: Write> Drop for DaemonClient<R, W> {
     fn drop(&mut self) {
-        let _ = self.command::<()>(DaemonCommand::Exit);
+        let _ = self.send_command(DaemonCommand::exit{});
     }
 }

src/daemon/mod.rs

@@ -9,7 +9,63 @@ mod client;
 pub use self::server::DaemonServer;
 mod server;
 
-pub trait Daemon {
+pub trait DaemonClientTrait {
+    fn send_command(&mut self, command: DaemonCommand) -> Result<DaemonResponse, String>;
+}
+
+// Define Daemon trait, DaemonCommand enum, and DaemonResponse enum
+macro_rules! commands {
+    ( $( fn $func:ident(&mut self $(,)? $( $arg:ident: $type:ty ),*) -> Result<$ret:ty, String>; )* ) => {
+        pub trait Daemon {
+        $(
+            fn $func(&mut self, $( $arg: $type ),*) -> Result<$ret, String>;
+        )*
+
+            fn dispatch_command_to_method(&mut self, command: DaemonCommand) -> Result<DaemonResponse, String> {
+                match command {
+                $(
+                    DaemonCommand::$func{$( $arg ),*} => {
+                        self.$func($( $arg ),*).map(DaemonResponse::$func)
+                    }
+                )*
+                }
+            }
+        }
+
+        #[allow(non_camel_case_types)]
+        #[derive(Deserialize, Serialize)]
+        #[serde(tag = "t", content = "c")]
+        pub enum DaemonCommand {
+        $(
+            $func{$( $arg: $type ),*}
+        ),*
+        }
+
+        #[allow(non_camel_case_types)]
+        #[derive(Deserialize, Serialize)]
+        #[serde(tag = "t", content = "c")]
+        pub enum DaemonResponse {
+        $(
+            $func($ret)
+        ),*
+        }
+
+        impl<T: DaemonClientTrait> Daemon for T {
+        $(
+            fn $func(&mut self, $( $arg: $type ),*) -> Result<$ret, String> {
+                let res = self.send_command(DaemonCommand::$func{$( $arg ),*});
+                match res {
+                    Ok(DaemonResponse::$func(ret)) => Ok(ret),
+                    Ok(_) => unreachable!(),
+                    Err(err) => Err(err),
+                }
+            }
+        )*
+        }
+    };
+}
+
+commands! {
     fn boards(&mut self) -> Result<Vec<String>, String>;
     fn keymap_get(&mut self, board: usize, layer: u8, output: u8, input: u8) -> Result<u16, String>;
     fn keymap_set(&mut self, board: usize, layer: u8, output: u8, input: u8, value: u16) -> Result<(), String>;
@@ -18,33 +74,13 @@ pub trait Daemon {
     fn max_brightness(&mut self) -> Result<i32, String>;
     fn brightness(&mut self) -> Result<i32, String>;
     fn set_brightness(&mut self, brightness: i32) -> Result<(), String>;
+    fn exit(&mut self) -> Result<(), String>;
 }
 
 fn err_str<E: std::fmt::Debug>(err: E) -> String {
     format!("{:?}", err)
 }
 
-#[derive(Deserialize, Serialize)]
-#[serde(tag = "kind")]
-enum DaemonCommand {
-    Boards,
-    KeymapGet { board: usize, layer: u8, output: u8, input: u8 },
-    KeymapSet { board: usize, layer: u8, output: u8, input: u8, value: u16 },
-    MaxBrightness,
-    Brightness,
-    Color,
-    SetBrightness { brightness: i32 },
-    SetColor { color: Rgb },
-    Exit,
-}
-
-#[derive(Deserialize, Serialize)]
-#[serde(untagged)]
-enum DaemonResult {
-    Ok { ok: String },
-    Err { err: String },
-}
-
 pub fn daemon_server() -> Result<DaemonServer<io::Stdin, io::Stdout>, String> {
     DaemonServer::new(io::stdin(), io::stdout())
 }

src/daemon/server.rs

@@ -2,7 +2,6 @@ use ectool::{Access, AccessHid, Ec};
 #[cfg(target_os = "linux")]
 use ectool::AccessLpcLinux;
 use hidapi::HidApi;
-use serde::Serialize;
 use std::{
     fs,
     io::{
@@ -12,6 +11,7 @@ use std::{
         Read,
         Write,
     },
+    process,
     str,
     time::Duration,
 };
@@ -21,7 +21,6 @@ use super::{
     err_str,
     Daemon,
     DaemonCommand,
-    DaemonResult,
 };
 
 pub struct DaemonServer<R: Read, W: Write> {
@@ -101,58 +100,16 @@ impl<R: Read, W: Write> DaemonServer<R, W> {
         })
     }
 
-    fn command(&mut self, command_json: &str) -> Result<String, String> {
-        fn json<T: Serialize>(value: T) -> Result<String, String> {
-            serde_json::to_string(&value).map_err(err_str)
-        }
-
-        let command = serde_json::from_str::<DaemonCommand>(&command_json).map_err(err_str)?;
-        match command {
-            DaemonCommand::Boards => {
-                json(self.boards()?)
-            },
-            DaemonCommand::KeymapGet { board, layer, output, input } => {
-                json(self.keymap_get(board, layer, output, input)?)
-            },
-            DaemonCommand::KeymapSet { board, layer, output, input, value } => {
-                json(self.keymap_set(board, layer, output, input, value)?)
-            },
-            DaemonCommand::Color => {
-                json(self.color()?)
-            }
-            DaemonCommand::SetColor { color } => {
-                self.set_color(color)?;
-                json(())
-            }
-            DaemonCommand::MaxBrightness => {
-                json(self.max_brightness()?)
-            }
-            DaemonCommand::Brightness => {
-                json(self.brightness()?)
-            }
-            DaemonCommand::SetBrightness { brightness } => {
-                self.set_brightness(brightness)?;
-                json(())
-            }
-            DaemonCommand::Exit => {
-                self.running = false;
-                json(())
-            },
-        }
-    }
-
     pub fn run(mut self) -> io::Result<()> {
         while self.running {
             let mut command_json = String::new();
             self.read.read_line(&mut command_json)?;
 
-            let result = match self.command(&command_json) {
-                Ok(ok) => DaemonResult::Ok { ok },
-                Err(err) => DaemonResult::Err { err },
-            };
+            let command = serde_json::from_str::<DaemonCommand>(&command_json).expect("failed to deserialize command");
+            let response = self.dispatch_command_to_method(command);
 
             //TODO: what to do if we fail to serialize result?
-            let mut result_json = serde_json::to_string(&result).expect("failed to serialize result");
+            let mut result_json = serde_json::to_string(&response).expect("failed to serialize result");
             result_json.push('\n');
             self.write.write_all(result_json.as_bytes())?;
         }
@@ -291,4 +248,8 @@ impl<R: Read, W: Write> Daemon for DaemonServer<R, W> {
             Err(err) => Err(format!("Failed to write keyboard brightness: {}", err))
         }
     }
+
+    fn exit(&mut self) -> Result<(), String> {
+        process::exit(0);
+    }
 }