improv: Add DaemonDummy

This adds some boilerplate for each command, but it eliminates the
annoying `daemon_opt: Option<Rc<dyn Daemon>>` nonsense.

This could also be useful for unit tests.

Author: ids1024

src/application/keyboard.rs

@@ -24,7 +24,7 @@ use super::page::Page;
 use super::picker::Picker;
 
 pub struct Keyboard {
-    pub(crate) daemon_opt: Option<Rc<dyn Daemon>>,
+    pub(crate) daemon: Rc<dyn Daemon>,
     pub(crate) daemon_board: usize,
     pub(crate) keymap: HashMap<String, u16>,
     pub(crate) keys: RefCell<Vec<Key>>,
@@ -34,7 +34,7 @@ pub struct Keyboard {
 }
 
 impl Keyboard {
-    pub fn new<P: AsRef<Path>>(dir: P, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Rc<Self> {
+    pub fn new<P: AsRef<Path>>(dir: P, daemon: Rc<dyn Daemon>, daemon_board: usize) -> Rc<Self> {
         let dir = dir.as_ref();
 
         let keymap_csv = fs::read_to_string(dir.join("keymap.csv"))
@@ -43,24 +43,20 @@ impl Keyboard {
             .expect("Failed to load layout.csv");
         let physical_json = fs::read_to_string(dir.join("physical.json"))
             .expect("Failed to load physical.json");
-        Self::new_data(&keymap_csv, &layout_csv, &physical_json, daemon_opt, daemon_board)
+        Self::new_data(&keymap_csv, &layout_csv, &physical_json, daemon, daemon_board)
     }
 
-    fn new_layout(layout: Layout, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Rc<Self> {
+    fn new_layout(layout: Layout, daemon: Rc<dyn Daemon>, daemon_board: usize) -> Rc<Self> {
         let mut keys = layout.keys();
         for key in keys.iter_mut() {
             for layer in 0..2 {
                 println!("  Layer {}", layer);
-                let scancode = if let Some(ref daemon) = daemon_opt {
-                    match daemon.keymap_get(daemon_board, layer, key.electrical.0, key.electrical.1) {
-                        Ok(value) => value,
-                        Err(err) => {
-                            eprintln!("Failed to read scancode: {:?}", err);
-                            0
-                        }
+                let scancode = match daemon.keymap_get(daemon_board, layer, key.electrical.0, key.electrical.1) {
+                    Ok(value) => value,
+                    Err(err) => {
+                        eprintln!("Failed to read scancode: {:?}", err);
+                        0
                     }
-                } else {
-                    0
                 };
                 println!("    Scancode: {:04X}", scancode);
 
@@ -75,7 +71,7 @@ impl Keyboard {
         }
 
         Rc::new(Self {
-            daemon_opt,
+            daemon,
             daemon_board,
             keymap: layout.keymap,
             keys: RefCell::new(keys),
@@ -85,15 +81,15 @@ impl Keyboard {
         })
     }
 
-    pub fn new_board(board: &str, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Option<Rc<Self>> {
+    pub fn new_board(board: &str, daemon: Rc<dyn Daemon>, daemon_board: usize) -> Option<Rc<Self>> {
         Layout::from_board(board).map(|layout|
-            Self::new_layout(layout, daemon_opt, daemon_board)
+            Self::new_layout(layout, daemon, daemon_board)
         )
     }
 
-    fn new_data(keymap_csv: &str, layout_csv: &str, physical_json: &str, daemon_opt: Option<Rc<dyn Daemon>>, daemon_board: usize) -> Rc<Self> {
+    fn new_data(keymap_csv: &str, layout_csv: &str, physical_json: &str, daemon: Rc<dyn Daemon>, daemon_board: usize) -> Rc<Self> {
         let layout = Layout::from_data(keymap_csv, layout_csv, physical_json);
-        Self::new_layout(layout, daemon_opt, daemon_board)
+        Self::new_layout(layout, daemon, daemon_board)
     }
 
     pub fn layer(&self) -> usize {
@@ -141,16 +137,12 @@ impl Keyboard {
             ..set_halign(gtk::Align::Start);
         };
 
-        let max_brightness = if let Some(ref daemon) = self.daemon_opt {
-            match daemon.max_brightness(self.daemon_board) {
-                Ok(value) => value as f64,
-                Err(err) => {
-                    eprintln!("{}", err);
-                    100.0
-                }
+        let max_brightness = match self.daemon.max_brightness(self.daemon_board) {
+            Ok(value) => value as f64,
+            Err(err) => {
+                eprintln!("{}", err);
+                100.0
             }
-        } else {
-            100.0
         };
 
         let brightness_scale = cascade! {
@@ -161,10 +153,8 @@ impl Keyboard {
         let kb = self.clone();
         brightness_scale.connect_value_changed(move |this| {
             let value = this.get_value() as i32;
-            if let Some(ref daemon) = kb.daemon_opt {
-                if let Err(err) = daemon.set_brightness(kb.daemon_board, value) {
-                    eprintln!("{}", err);
-                }
+            if let Err(err) = kb.daemon.set_brightness(kb.daemon_board, value) {
+                eprintln!("{}", err);
             }
             println!("{}", value);
 
@@ -175,12 +165,7 @@ impl Keyboard {
             ..set_halign(gtk::Align::Start);
         };
 
-        let color_keyboard = if let Some(ref daemon) = self.daemon_opt {
-            ColorKeyboard::new_daemon(daemon.clone(), self.daemon_board)
-        } else {
-
-            ColorKeyboard::new_dummy()
-        };
+        let color_keyboard = ColorKeyboard::new_daemon(self.daemon.clone(), self.daemon_board);
         let color_button = KeyboardColorButton::new(color_keyboard);
         color_button.set_valign(gtk::Align::Center);
 

src/application/mod.rs

@@ -3,7 +3,7 @@ use gio::prelude::*;
 use gtk::prelude::*;
 use std::rc::Rc;
 
-use crate::daemon::{Daemon, DaemonClient, daemon_server};
+use crate::daemon::{Daemon, DaemonClient, DaemonDummy, daemon_server};
 
 mod key;
 mod keyboard;
@@ -51,7 +51,7 @@ fn main_app(app: &gtk::Application, daemon: Rc<dyn Daemon>) {
 
     let mut count = 0;
     for (i, board) in boards.iter().enumerate() {
-        if let Some(keyboard) = Keyboard::new_board(board, Some(daemon.clone()), i) {
+        if let Some(keyboard) = Keyboard::new_board(board, daemon.clone(), i) {
             let widget = main_keyboard(app, keyboard);
             board_dropdown.append(Some(&board), &board);
             stack.add_named(&widget, &board);
@@ -66,18 +66,27 @@ fn main_app(app: &gtk::Application, daemon: Rc<dyn Daemon>) {
         }
     }
 
-    if count == 0 {
+    if count == 1 {
         eprintln!("Failed to locate any keyboards, showing demo");
-        let board = "system76/launch_alpha_2";
-        let keyboard = Keyboard::new_board(board, None, 0)
-            .expect("Failed to load demo layout");
 
-        let widget = main_keyboard(app, keyboard);
-        board_dropdown.append(Some(board), board);
-        stack.add_named(&widget, board);
-
-        widget.show();
-        board_dropdown.set_active_id(Some(board));
+        let daemon = Rc::new(DaemonDummy::new());
+        let boards = daemon.boards().unwrap();
+
+        for (i, board) in boards.iter().enumerate() {
+            if let Some(keyboard) = Keyboard::new_board(board, daemon.clone(), i) {
+                let widget = main_keyboard(app, keyboard);
+                board_dropdown.append(Some(&board), &board);
+                stack.add_named(&widget, &board);
+                count += 1;
+
+                if count == 1 {
+                    widget.show();
+                    board_dropdown.set_active_id(Some(&board));
+                }
+            } else {
+                eprintln!("Failed to locate layout for '{}'", board);
+            }
+        }
     }
 
     let vbox = cascade! {

src/application/picker/mod.rs

@@ -192,16 +192,14 @@ impl Picker {
                             "  set {}, {}, {} to {:04X}",
                             layer, k.electrical.0, k.electrical.1, k.scancodes[layer].0
                         );
-                        if let Some(ref daemon) = kb.daemon_opt {
-                            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);
-                            }
+                        if let Err(err) = kb.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);
                         }
                     }
                 }));

src/color.rs

@@ -23,7 +23,7 @@ impl Hs {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Default)]
 pub struct Rgb {
     /// Red
     pub r: u8,

src/daemon/dummy.rs

@@ -0,0 +1,82 @@
+use std::{
+    cell::{
+        Cell,
+        RefCell,
+    },
+    collections::HashMap,
+};
+
+use crate::color::Rgb;
+use super::Daemon;
+
+#[derive(Default)]
+struct BoardDummy {
+    keymap: RefCell<HashMap<(u8, u8, u8), u16>>,
+    color: Cell<Rgb>,
+    brightness: Cell<i32>,
+}
+
+pub struct DaemonDummy {
+    board_names: Vec<String>,
+    boards: Vec<BoardDummy>,
+}
+
+impl DaemonDummy {
+    fn board(&self, board: usize) -> Result<&BoardDummy, String> {
+        self.boards.get(board).ok_or("No board".to_string())
+    }
+}
+
+impl DaemonDummy {
+    pub fn new() -> Self {
+        let board_names = vec!["system76/launch_alpha_2".to_string()];
+        let boards = board_names.iter().map(|_| BoardDummy::default()).collect();
+        Self {
+            board_names,
+            boards,
+        }
+    }
+}
+
+impl Daemon for DaemonDummy {
+    fn boards(&self) -> Result<Vec<String>, String> {
+        Ok(self.board_names.clone())
+    }
+
+    fn keymap_get(&self, board: usize, layer: u8, output: u8, input: u8) -> Result<u16, String> {
+        let keymap = self.board(board)?.keymap.borrow();
+        Ok(keymap.get(&(layer, output, input)).copied().unwrap_or(0))
+    }
+
+    fn keymap_set(&self, board: usize, layer: u8, output: u8, input: u8, value: u16) -> Result<(), String> {
+        let mut keymap = self.board(board)?.keymap.borrow_mut();
+        keymap.insert((layer, output, input), value);
+        Ok(())
+    }
+
+    fn color(&self, board: usize) -> Result<Rgb, String> {
+        Ok(self.board(board)?.color.get())
+    }
+
+    fn set_color(&self, board: usize, color: Rgb) -> Result<(), String> {
+        self.board(board)?.color.set(color);
+        Ok(())
+    }
+
+    fn max_brightness(&self, _board: usize) -> Result<i32, String> {
+        Ok(100)
+    }
+
+    fn brightness(&self, board: usize) -> Result<i32, String> {
+        Ok(self.board(board)?.brightness.get())
+    }
+
+    fn set_brightness(&self, board: usize, brightness: i32) -> Result<(), String> {
+        self.board(board)?.brightness.set(brightness);
+        Ok(())
+    }
+
+    fn exit(&self) -> Result<(), String> {
+        Ok(())
+    }
+}

src/daemon/mod.rs

@@ -9,6 +9,9 @@ mod client;
 pub use self::server::DaemonServer;
 mod server;
 
+pub use self::dummy::DaemonDummy;
+mod dummy;
+
 pub trait DaemonClientTrait {
     fn send_command(&self, command: DaemonCommand) -> Result<DaemonResponse, String>;
 }