improv: Use RefCell internally in implementation of Daemon

`Rc<dyn Daemon>` is a nicer type to be passing around than
`Rc<RefCell<dyn Daemon>>`. Dealing with mutability this way isn't really
idiomatic Rust, but is idiomatic gtk/gtk-rs.

Author: ids1024

src/application/keyboard.rs

@@ -23,7 +23,7 @@ use super::picker::Picker;
 use super::rect::Rect;
 
 pub struct Keyboard {
-    daemon_opt: Option<Rc<RefCell<dyn Daemon>>>,
+    daemon_opt: Option<Rc<dyn Daemon>>,
     daemon_board: usize,
     keymap: HashMap<String, u16>,
     keys: RefCell<Vec<Key>>,
@@ -33,7 +33,7 @@ pub struct Keyboard {
 }
 
 impl Keyboard {
-    pub fn new<P: AsRef<Path>>(dir: P, daemon_opt: Option<Rc<RefCell<dyn Daemon>>>, daemon_board: usize) -> Rc<Self> {
+    pub fn new<P: AsRef<Path>>(dir: P, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Rc<Self> {
         let dir = dir.as_ref();
 
         let keymap_csv = fs::read_to_string(dir.join("keymap.csv"))
@@ -45,7 +45,7 @@ impl Keyboard {
         Self::new_data(&keymap_csv, &layout_csv, &physical_json, daemon_opt, daemon_board)
     }
 
-    pub fn new_board(board: &str, daemon_opt: Option<Rc<RefCell<dyn Daemon>>>, daemon_board: usize) -> Option<Rc<Self>> {
+    pub fn new_board(board: &str, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Option<Rc<Self>> {
         macro_rules! keyboard {
             ($board:expr) => (if board == $board {
                 let keymap_csv = include_str!(concat!("../../layouts/", $board, "/keymap.csv"));
@@ -69,7 +69,7 @@ impl Keyboard {
         None
     }
 
-    fn new_data(keymap_csv: &str, layout_csv: &str, physical_json: &str, daemon_opt: Option<Rc<RefCell<dyn Daemon>>>, daemon_board: usize) -> Rc<Self> {
+    fn new_data(keymap_csv: &str, layout_csv: &str, physical_json: &str, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Rc<Self> {
         let mut keymap = HashMap::new();
         let mut scancode_names = HashMap::new();
         scancode_names.insert(0, "NONE");
@@ -181,7 +181,6 @@ impl Keyboard {
                                     for layer in 0..2 {
                                         println!("  Layer {}", layer);
                                         let scancode = if let Some(ref daemon) = daemon_opt {
-                                            let mut daemon = daemon.borrow_mut();
                                             match daemon.keymap_get(daemon_board, layer, electrical.0, electrical.1) {
                                                 Ok(value) => value,
                                                 Err(err) => {
@@ -353,7 +352,6 @@ button {
                         }
                         println!("  set {}, {}, {} to {:04X}", layer, k.electrical.0, k.electrical.1, k.scancodes[layer].0);
                         if let Some(ref daemon) = kb.daemon_opt {
-                            let mut daemon = daemon.borrow_mut();
                             if let Err(err) = daemon.keymap_set(kb.daemon_board, layer as u8, k.electrical.0, k.electrical.1, k.scancodes[layer].0) {
                                 eprintln!("Failed to set keymap: {:?}", err);
                             }
@@ -410,7 +408,6 @@ button {
         };
 
         let max_brightness = if let Some(ref daemon) = self.daemon_opt {
-            let mut daemon = daemon.borrow_mut();
             match daemon.max_brightness(self.daemon_board) {
                 Ok(value) => value as f64,
                 Err(err) => {
@@ -431,7 +428,6 @@ button {
         brightness_scale.connect_value_changed(move |this| {
             let value = this.get_value() as i32;
             if let Some(ref daemon) = kb.daemon_opt {
-                let mut daemon = daemon.borrow_mut();
                 if let Err(err) = daemon.set_brightness(kb.daemon_board, value) {
                     eprintln!("{}", err);
                 }
@@ -446,7 +442,6 @@ button {
         };
 
         let color_rgba = if let Some(ref daemon) = self.daemon_opt {
-            let mut daemon = daemon.borrow_mut();
             match daemon.color(self.daemon_board) {
                 Ok(value) => {
                     let (red, green, blue) = value.to_floats();
@@ -468,7 +463,6 @@ button {
             let rgba = this.get_rgba();
             let color = Rgb::from_floats(rgba.red, rgba.green, rgba.blue);
             if let Some(ref daemon) = kb.daemon_opt {
-                let mut daemon = daemon.borrow_mut();
                 if let Err(err) = daemon.set_color(kb.daemon_board, color) {
                     eprintln!("{}", err);
                 }

src/application/mod.rs

@@ -1,7 +1,6 @@
 use cascade::cascade;
 use gio::prelude::*;
 use gtk::prelude::*;
-use std::cell::RefCell;
 use std::rc::Rc;
 
 use crate::daemon::{Daemon, DaemonClient, daemon_server};
@@ -44,8 +43,8 @@ fn main_keyboard(app: &gtk::Application, keyboard: Rc<Keyboard>) {
     });
 }
 
-fn main_app(app: &gtk::Application, daemon: Rc<RefCell<dyn Daemon>>) {
-    let boards = daemon.borrow_mut().boards().expect("Failed to load boards");
+fn main_app(app: &gtk::Application, daemon: Rc<dyn Daemon>) {
+    let boards = daemon.boards().expect("Failed to load boards");
     let i = 0;
     if let Some(board) = boards.get(i) {
         if let Some(keyboard) = Keyboard::new_board(board, Some(daemon), i) {
@@ -63,7 +62,7 @@ fn main_app(app: &gtk::Application, daemon: Rc<RefCell<dyn Daemon>>) {
 }
 
 #[cfg(target_os = "linux")]
-fn with_daemon<F: Fn(Rc<RefCell<dyn Daemon>>)>(f: F) {
+fn with_daemon<F: Fn(Rc<dyn Daemon>)>(f: F) {
     use std::{
         process::{
             Command,
@@ -74,7 +73,7 @@ fn with_daemon<F: Fn(Rc<RefCell<dyn Daemon>>)>(f: F) {
     if unsafe { libc::geteuid() == 0 } {
         eprintln!("Already running as root");
         let server = daemon_server().expect("Failed to create server");
-        f(Rc::new(RefCell::new(server)));
+        f(Rc::new(server));
         return;
     }
 
@@ -96,7 +95,7 @@ fn with_daemon<F: Fn(Rc<RefCell<dyn Daemon>>)>(f: F) {
     let stdin = child.stdin.take().expect("Failed to get stdin of daemon");
     let stdout = child.stdout.take().expect("Failed to get stdout of daemon");
 
-    f(Rc::new(RefCell::new(DaemonClient::new(stdout, stdin))));
+    f(Rc::new(DaemonClient::new(stdout, stdin)));
 
     let status = child.wait().expect("Failed to wait for daemon");
     if ! status.success() {

src/daemon/client.rs

@@ -1,4 +1,5 @@
 use std::{
+    cell::RefCell,
     io::{
         BufRead,
         BufReader,
@@ -15,27 +16,27 @@ use super::{
 };
 
 pub struct DaemonClient<R: Read, W: Write> {
-    read: BufReader<R>,
-    write: W,
+    read: RefCell<BufReader<R>>,
+    write: RefCell<W>,
 }
 
 impl<R: Read, W: Write> DaemonClient<R, W> {
     pub fn new(read: R, write: W) -> Self {
         Self {
-            read: BufReader::new(read),
-            write,
+            read: RefCell::new(BufReader::new(read)),
+            write: RefCell::new(write),
         }
     }
 }
 
 impl<R: std::io::Read, W: std::io::Write> DaemonClientTrait for DaemonClient<R, W> {
-    fn send_command(&mut self, command: DaemonCommand) -> Result<DaemonResponse, String> {
+    fn send_command(&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)?;
+        self.write.borrow_mut().write_all(command_json.as_bytes()).map_err(err_str)?;
 
         let mut response_json = String::new();
-        self.read.read_line(&mut response_json).map_err(err_str)?;
+        self.read.borrow_mut().read_line(&mut response_json).map_err(err_str)?;
         serde_json::from_str(&response_json).map_err(err_str)?
     }
 }

src/daemon/mod.rs

@@ -10,18 +10,18 @@ pub use self::server::DaemonServer;
 mod server;
 
 pub trait DaemonClientTrait {
-    fn send_command(&mut self, command: DaemonCommand) -> Result<DaemonResponse, String>;
+    fn send_command(&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>; )* ) => {
+    ( $( fn $func:ident(&self $(,)? $( $arg:ident: $type:ty ),*) -> Result<$ret:ty, String>; )* ) => {
         pub trait Daemon {
         $(
-            fn $func(&mut self, $( $arg: $type ),*) -> Result<$ret, String>;
+            fn $func(&self, $( $arg: $type ),*) -> Result<$ret, String>;
         )*
 
-            fn dispatch_command_to_method(&mut self, command: DaemonCommand) -> Result<DaemonResponse, String> {
+            fn dispatch_command_to_method(&self, command: DaemonCommand) -> Result<DaemonResponse, String> {
                 match command {
                 $(
                     DaemonCommand::$func{$( $arg ),*} => {
@@ -52,7 +52,7 @@ macro_rules! commands {
 
         impl<T: DaemonClientTrait> Daemon for T {
         $(
-            fn $func(&mut self, $( $arg: $type ),*) -> Result<$ret, String> {
+            fn $func(&self, $( $arg: $type ),*) -> Result<$ret, String> {
                 let res = self.send_command(DaemonCommand::$func{$( $arg ),*});
                 match res {
                     Ok(DaemonResponse::$func(ret)) => Ok(ret),
@@ -66,15 +66,15 @@ macro_rules! commands {
 }
 
 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>;
-    fn color(&mut self, board: usize) -> Result<Rgb, String>;
-    fn set_color(&mut self, board: usize, color: Rgb) -> Result<(), String>;
-    fn max_brightness(&mut self, board: usize) -> Result<i32, String>;
-    fn brightness(&mut self, board: usize) -> Result<i32, String>;
-    fn set_brightness(&mut self, board: usize, brightness: i32) -> Result<(), String>;
-    fn exit(&mut self) -> Result<(), String>;
+    fn boards(&self) -> Result<Vec<String>, String>;
+    fn keymap_get(&self, board: usize, layer: u8, output: u8, input: u8) -> Result<u16, String>;
+    fn keymap_set(&self, board: usize, layer: u8, output: u8, input: u8, value: u16) -> Result<(), String>;
+    fn color(&self, board: usize) -> Result<Rgb, String>;
+    fn set_color(&self, board: usize, color: Rgb) -> Result<(), String>;
+    fn max_brightness(&self, board: usize) -> Result<i32, String>;
+    fn brightness(&self, board: usize) -> Result<i32, String>;
+    fn set_brightness(&self, board: usize, brightness: i32) -> Result<(), String>;
+    fn exit(&self) -> Result<(), String>;
 }
 
 fn err_str<E: std::fmt::Debug>(err: E) -> String {