Unwrap evdev::Key

src/config/key.rs

@@ -1,61 +1,31 @@
 use serde::de::Visitor;
-use serde::{Deserialize, Deserializer};
+use serde::Deserializer;
 use std::error::Error;
-use std::fmt::{Debug, Formatter};
+use std::fmt;
 use std::str::FromStr;
 
-// A wrapper of evdev::Key just to ease deserialization
-#[derive(Clone, Eq, PartialEq, Hash)]
-pub struct Key {
-    key: evdev::Key,
-}
-
-impl Key {
-    #[inline]
-    pub const fn new(code: u16) -> Self {
-        Key {
-            key: evdev::Key::new(code),
-        }
-    }
-
-    #[inline]
-    pub const fn code(&self) -> u16 {
-        self.key.code()
-    }
-}
+pub fn deserialize_key<'de, D>(deserializer: D) -> Result<evdev::Key, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct KeyVisitor;
 
-impl Debug for Key {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.key.fmt(f)
-    }
-}
-
-impl<'de> Deserialize<'de> for Key {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct KeyVisitor;
-
-        impl<'de> Visitor<'de> for KeyVisitor {
-            type Value = Key;
+    impl<'de> Visitor<'de> for KeyVisitor {
+        type Value = evdev::Key;
 
-            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
-                formatter.write_str("string")
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                Ok(Key {
-                    key: parse_key(value).map_err(serde::de::Error::custom)?,
-                })
-            }
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("string")
         }
 
-        deserializer.deserialize_any(KeyVisitor)
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(parse_key(value).map_err(serde::de::Error::custom)?)
+        }
     }
+
+    deserializer.deserialize_any(KeyVisitor)
 }
 
 pub fn parse_key(input: &str) -> Result<evdev::Key, Box<dyn Error>> {

src/config/key_action.rs

@@ -1,17 +1,21 @@
-use crate::config::key::Key;
+use crate::config::key::deserialize_key;
+use evdev::Key;
 use serde::Deserialize;
 
 // Values in `modmap.remap`
 #[derive(Clone, Debug, Deserialize)]
 #[serde(untagged)]
 pub enum KeyAction {
+    #[serde(deserialize_with = "deserialize_key")]
     Key(Key),
     MultiPurposeKey(MultiPurposeKey),
 }
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct MultiPurposeKey {
+    #[serde(deserialize_with = "deserialize_key")]
     pub held: Key,
+    #[serde(deserialize_with = "deserialize_key")]
     pub alone: Key,
     #[serde(default = "MultiPurposeKey::default_alone_timeout_millis")]
     pub alone_timeout_millis: u64,

src/config/key_press.rs

@@ -1,4 +1,5 @@
-use crate::config::key::{parse_key, Key};
+use crate::config::key::parse_key;
+use evdev::Key;
 use serde::de;
 use serde::de::Visitor;
 use serde::{Deserialize, Deserializer};

src/config/modmap.rs

@@ -1,7 +1,8 @@
 use crate::config::application::Application;
-use crate::config::key::Key;
+use crate::config::key::deserialize_key;
 use crate::config::key_action::KeyAction;
-use serde::Deserialize;
+use evdev::Key;
+use serde::{Deserialize, Deserializer};
 use std::collections::HashMap;
 
 #[derive(Debug, Deserialize)]
@@ -9,6 +10,18 @@ use std::collections::HashMap;
 pub struct Modmap {
     #[serde(default = "String::new")]
     pub name: String,
+    #[serde(deserialize_with = "deserialize_remap")]
     pub remap: HashMap<Key, KeyAction>,
     pub application: Option<Application>,
 }
+
+fn deserialize_remap<'de, D>(deserializer: D) -> Result<HashMap<Key, KeyAction>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    #[derive(Deserialize, Eq, Hash, PartialEq)]
+    struct KeyWrapper(#[serde(deserialize_with = "deserialize_key")] Key);
+
+    let v = HashMap::<KeyWrapper, KeyAction>::deserialize(deserializer)?;
+    Ok(v.into_iter().map(|(KeyWrapper(k), v)| (k, v)).collect())
+}

src/event_handler.rs

@@ -1,12 +1,11 @@
 use crate::client::{build_client, WMClient};
 use crate::config::action::Action;
 use crate::config::application::Application;
-use crate::config::key::Key;
 use crate::config::key_action::KeyAction;
 use crate::config::key_press::{KeyPress, Modifier};
 use crate::Config;
 use evdev::uinput::VirtualDevice;
-use evdev::{EventType, InputEvent};
+use evdev::{EventType, InputEvent, Key};
 use lazy_static::lazy_static;
 use log::debug;
 use std::collections::HashMap;