Separate Key into Character and NamedKey

This makes most of the key Copy, and allows other crates like Winit to
more easily use their own string types.

Author: madsmtm

convert.py

@@ -42,7 +42,7 @@ def parse(text):
                 code.replace_with(f"[`{text}`][Code::{text}]")
             for code in typical_usage.find_all(class_='key'):
                 text = code.text.strip().strip('"')
-                code.replace_with(f"[`{text}`][Key::{text}]")
+                code.replace_with(f"[`{text}`][NamedKey::{text}]")
 
             comment = re.sub(r"[ \t][ \t]+", "\n", typical_usage.decode_contents())
 
@@ -106,15 +106,10 @@ def convert_key(text, file):
 ///
 /// Specification:
 /// <https://w3c.github.io/uievents-key/>
-#[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[non_exhaustive]
-pub enum Key {
-    /// A key string that corresponds to the character typed by the user,
-    /// taking into account the user’s current locale setting, modifier state,
-    /// and any system-level keyboard mapping overrides that are in effect.
-    Character(String),
-    """, file=file)
+pub enum NamedKey {""", file=file)
     display = parse(text)
 
     for i in range(1, 36):
@@ -130,64 +125,40 @@ def convert_key(text, file):
 
     print("""
 
-impl Display for Key {
+impl Display for NamedKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::Key::*;
-        match *self {
-            Character(ref s) => write!(f, "{}", s),
-    """, file=file)
+        use self::NamedKey::*;
+        match *self {""", file=file)
     print_display_entries(display, file)
     print("""
         }
     }
 }
 
-impl FromStr for Key {
-    type Err = UnrecognizedKeyError;
+impl FromStr for NamedKey {
+    type Err = UnrecognizedNamedKeyError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use crate::Key::*;
-        match s {
-            s if is_key_string(s) => Ok(Character(s.to_string())),""", file=file)
+        use crate::NamedKey::*;
+        match s {""", file=file)
     print_from_str_entries(display, file)
     print("""
-            _ => Err(UnrecognizedKeyError),
+            _ => Err(UnrecognizedNamedKeyError),
         }
     }
 }
 
 /// Parse from string error, returned when string does not match to any Key variant.
 #[derive(Clone, Debug)]
-pub struct UnrecognizedKeyError;
+pub struct UnrecognizedNamedKeyError;
 
-impl fmt::Display for UnrecognizedKeyError {
+impl fmt::Display for UnrecognizedNamedKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "Unrecognized key")
     }
 }
 
-impl Error for UnrecognizedKeyError {}
-
-/// Check if string can be used as a `Key::Character` _keystring_.
-///
-/// This check is simple and is meant to prevents common mistakes like mistyped keynames
-/// (e.g. `Ennter`) from being recognized as characters.
-fn is_key_string(s: &str) -> bool {
-    s.chars().all(|c| !c.is_control()) && s.chars().skip(1).all(|c| !c.is_ascii())
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_is_key_string() {
-        assert!(is_key_string("A"));
-        assert!(!is_key_string("AA"));
-        assert!(!is_key_string("\t"));
-    }
-}
-    """, file=file)
+impl Error for UnrecognizedNamedKeyError {}""", file=file)
 
 
 def convert_code(text, file):
@@ -273,8 +244,7 @@ def convert_code(text, file):
 impl Display for Code {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::Code::*;
-        match *self {
-    """, file=file)
+        match *self {""", file=file)
     print_display_entries(display, file)
     print("""
         }
@@ -304,13 +274,12 @@ def convert_code(text, file):
     }
 }
 
-impl Error for UnrecognizedCodeError {}
-    """, file=file)
+impl Error for UnrecognizedCodeError {}""", file=file)
 
 
 if __name__ == '__main__':
     input = requests.get('https://w3c.github.io/uievents-key/').text
-    with open('src/key.rs', 'w', encoding='utf-8') as output:
+    with open('src/named_key.rs', 'w', encoding='utf-8') as output:
         convert_key(input, output)
     input = requests.get('https://w3c.github.io/uievents-code/').text
     with open('src/code.rs', 'w', encoding='utf-8') as output:

src/code.rs

@@ -475,7 +475,6 @@ impl Display for Code {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::Code::*;
         match *self {
-    
             Backquote => f.write_str("Backquote"),
             Backslash => f.write_str("Backslash"),
             BracketLeft => f.write_str("BracketLeft"),
@@ -936,4 +935,3 @@ impl fmt::Display for UnrecognizedCodeError {
 }
 
 impl Error for UnrecognizedCodeError {}
-    

src/lib.rs

@@ -6,16 +6,19 @@
 
 #![warn(clippy::doc_markdown)]
 
+use core::fmt;
+use core::str::FromStr;
+
 pub use crate::code::{Code, UnrecognizedCodeError};
-pub use crate::key::{Key, UnrecognizedKeyError};
 pub use crate::location::Location;
 pub use crate::modifiers::Modifiers;
+pub use crate::named_key::{NamedKey, UnrecognizedNamedKeyError};
 pub use crate::shortcuts::ShortcutMatcher;
 
 mod code;
-mod key;
 mod location;
 mod modifiers;
+mod named_key;
 mod shortcuts;
 #[cfg(feature = "webdriver")]
 pub mod webdriver;
@@ -149,6 +152,44 @@ pub struct CompositionEvent {
     pub data: String,
 }
 
+/// The value recieved from the keypress.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum Key {
+    /// A key string that corresponds to the character typed by the user,
+    /// taking into account the user’s current locale setting, modifier state,
+    /// and any system-level keyboard mapping overrides that are in effect.
+    Character(String),
+    Named(NamedKey),
+}
+
+/// Parse from string error, returned when string does not match to any Key variant.
+#[derive(Clone, Debug)]
+pub struct UnrecognizedKeyError;
+
+impl fmt::Display for Key {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Character(s) => f.write_str(s),
+            Self::Named(k) => k.fmt(f),
+        }
+    }
+}
+
+impl FromStr for Key {
+    type Err = UnrecognizedKeyError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if is_key_string(s) {
+            Ok(Self::Character(s.to_string()))
+        } else {
+            Ok(Self::Named(
+                NamedKey::from_str(s).map_err(|_| UnrecognizedKeyError)?,
+            ))
+        }
+    }
+}
+
 impl Key {
     /// Determine a *charCode* value for a key with a character value.
     ///
@@ -161,7 +202,7 @@ impl Key {
         // otherwise 0
         match self {
             Key::Character(ref c) => c.chars().next().unwrap_or('\0') as u32,
-            _ => 0,
+            Key::Named(_) => 0,
         }
     }
 
@@ -173,23 +214,23 @@ impl Key {
     pub fn legacy_keycode(&self) -> u32 {
         match self {
             // See: https://w3c.github.io/uievents/#fixed-virtual-key-codes
-            Key::Backspace => 8,
-            Key::Tab => 9,
-            Key::Enter => 13,
-            Key::Shift => 16,
-            Key::Control => 17,
-            Key::Alt => 18,
-            Key::CapsLock => 20,
-            Key::Escape => 27,
-            Key::PageUp => 33,
-            Key::PageDown => 34,
-            Key::End => 35,
-            Key::Home => 36,
-            Key::ArrowLeft => 37,
-            Key::ArrowUp => 38,
-            Key::ArrowRight => 39,
-            Key::ArrowDown => 40,
-            Key::Delete => 46,
+            Key::Named(NamedKey::Backspace) => 8,
+            Key::Named(NamedKey::Tab) => 9,
+            Key::Named(NamedKey::Enter) => 13,
+            Key::Named(NamedKey::Shift) => 16,
+            Key::Named(NamedKey::Control) => 17,
+            Key::Named(NamedKey::Alt) => 18,
+            Key::Named(NamedKey::CapsLock) => 20,
+            Key::Named(NamedKey::Escape) => 27,
+            Key::Named(NamedKey::PageUp) => 33,
+            Key::Named(NamedKey::PageDown) => 34,
+            Key::Named(NamedKey::End) => 35,
+            Key::Named(NamedKey::Home) => 36,
+            Key::Named(NamedKey::ArrowLeft) => 37,
+            Key::Named(NamedKey::ArrowUp) => 38,
+            Key::Named(NamedKey::ArrowRight) => 39,
+            Key::Named(NamedKey::ArrowDown) => 40,
+            Key::Named(NamedKey::Delete) => 46,
             Key::Character(ref c) if c.len() == 1 => match first_char(c) {
                 ' ' => 32,
                 x @ '0'..='9' => x as u32,
@@ -221,8 +262,14 @@ impl Default for KeyState {
 }
 
 impl Default for Key {
-    fn default() -> Key {
-        Key::Unidentified
+    fn default() -> Self {
+        Self::Named(NamedKey::default())
+    }
+}
+
+impl Default for NamedKey {
+    fn default() -> Self {
+        Self::Unidentified
     }
 }
 
@@ -245,3 +292,23 @@ impl Default for Location {
 fn first_char(s: &str) -> char {
     s.chars().next().expect("empty string")
 }
+
+/// Check if string can be used as a `Key::Character` _keystring_.
+///
+/// This check is simple and is meant to prevents common mistakes like mistyped keynames
+/// (e.g. `Ennter`) from being recognized as characters.
+fn is_key_string(s: &str) -> bool {
+    s.chars().all(|c| !c.is_control()) && s.chars().skip(1).all(|c| !c.is_ascii())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_is_key_string() {
+        assert!(is_key_string("A"));
+        assert!(!is_key_string("AA"));
+        assert!(!is_key_string("	"));
+    }
+}