Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
179 lines
6.5 KiB
Rust
179 lines
6.5 KiB
Rust
//! Option layer — macOS Option+key characters read back as the Alt chords they were pressed as.
|
||
//!
|
||
//! On a Mac the Option key types characters: `⌥O` is `ø`, `⌥P` is `π`. A terminal can be told to
|
||
//! treat it as Alt instead, and Ghostty does that by default only for the "U.S." layouts. On the
|
||
//! others, "ABC" among them, Ghostty sends the typed character *with* the Alt flag set, so `⌥O`
|
||
//! arrives as `Alt+ø`: no binding names it, and the composer ignores an Alt chord, so the key does
|
||
//! nothing at all. Option combinations that type nothing (the accent keys `E`, `I`, `N`, `U`, `` ` ``)
|
||
//! arrive as plain `Alt+e` and so on, which is why some Alt chords worked and others did not.
|
||
//!
|
||
//! The Alt flag is what makes this safe to undo. A character typed from a layout that has it on a
|
||
//! key of its own (`ø` on a Norwegian keyboard) arrives without Alt and is left alone; only a
|
||
//! character that came with Alt held is read back to the key that made it. The table is the "ABC"
|
||
//! and "U.S." Option layer, which every Mac ships and which the two share.
|
||
|
||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||
|
||
/// `key` with an Option-layer character read back to the key it was typed on, when it came with
|
||
/// Alt held; anything else unchanged.
|
||
pub(crate) fn normalize(key: KeyEvent) -> KeyEvent {
|
||
let KeyCode::Char(typed) = key.code else { return key };
|
||
if typed.is_ascii() || !key.modifiers.contains(KeyModifiers::ALT) {
|
||
return key;
|
||
}
|
||
match base_key(typed) {
|
||
Some((base, shifted)) => {
|
||
let modifiers = match shifted {
|
||
true => key.modifiers | KeyModifiers::SHIFT,
|
||
false => key.modifiers,
|
||
};
|
||
KeyEvent { code: KeyCode::Char(base), modifiers, ..key }
|
||
}
|
||
None => key,
|
||
}
|
||
}
|
||
|
||
/// The key an Option-layer character is typed on, and whether Shift was part of it.
|
||
fn base_key(typed: char) -> Option<(char, bool)> {
|
||
let plain = match typed {
|
||
'å' => 'a',
|
||
'∫' => 'b',
|
||
'ç' => 'c',
|
||
'∂' => 'd',
|
||
'ƒ' => 'f',
|
||
'©' => 'g',
|
||
'˙' => 'h',
|
||
'∆' => 'j',
|
||
'˚' => 'k',
|
||
'¬' => 'l',
|
||
'µ' => 'm',
|
||
'ø' => 'o',
|
||
'π' => 'p',
|
||
'œ' => 'q',
|
||
'®' => 'r',
|
||
'ß' => 's',
|
||
'†' => 't',
|
||
'√' => 'v',
|
||
'∑' => 'w',
|
||
'≈' => 'x',
|
||
'¥' => 'y',
|
||
'Ω' => 'z',
|
||
'¡' => '1',
|
||
'™' => '2',
|
||
'£' => '3',
|
||
'¢' => '4',
|
||
'∞' => '5',
|
||
'§' => '6',
|
||
'¶' => '7',
|
||
'•' => '8',
|
||
'ª' => '9',
|
||
'º' => '0',
|
||
'–' => '-',
|
||
'≠' => '=',
|
||
'“' => '[',
|
||
'‘' => ']',
|
||
'«' => '\\',
|
||
'…' => ';',
|
||
'æ' => '\'',
|
||
'≤' => ',',
|
||
'≥' => '.',
|
||
'÷' => '/',
|
||
_ => return shifted_base_key(typed).map(|base| (base, true)),
|
||
};
|
||
Some((plain, false))
|
||
}
|
||
|
||
/// The letter a Shift+Option character is typed on.
|
||
fn shifted_base_key(typed: char) -> Option<char> {
|
||
Some(match typed {
|
||
'Å' => 'a',
|
||
'ı' => 'b',
|
||
'Ç' => 'c',
|
||
'Î' => 'd',
|
||
'´' => 'e',
|
||
'Ï' => 'f',
|
||
'˝' => 'g',
|
||
'Ó' => 'h',
|
||
'ˆ' => 'i',
|
||
'Ô' => 'j',
|
||
'\u{f8ff}' => 'k',
|
||
'Ò' => 'l',
|
||
'Â' => 'm',
|
||
'˜' => 'n',
|
||
'Ø' => 'o',
|
||
'∏' => 'p',
|
||
'Œ' => 'q',
|
||
'‰' => 'r',
|
||
'Í' => 's',
|
||
'ˇ' => 't',
|
||
'¨' => 'u',
|
||
'◊' => 'v',
|
||
'„' => 'w',
|
||
'˛' => 'x',
|
||
'Á' => 'y',
|
||
'¸' => 'z',
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
fn key(code: char, modifiers: KeyModifiers) -> KeyEvent {
|
||
KeyEvent::new(KeyCode::Char(code), modifiers)
|
||
}
|
||
|
||
/// `⌥O` from Ghostty on the "ABC" layout is the chord the preview advertises.
|
||
#[test]
|
||
fn an_option_character_held_with_alt_is_the_alt_chord() {
|
||
assert_eq!(normalize(key('ø', KeyModifiers::ALT)), key('o', KeyModifiers::ALT));
|
||
assert_eq!(normalize(key('π', KeyModifiers::ALT)), key('p', KeyModifiers::ALT));
|
||
assert_eq!(normalize(key('∑', KeyModifiers::ALT)), key('w', KeyModifiers::ALT));
|
||
assert_eq!(
|
||
normalize(key('Ø', KeyModifiers::ALT)),
|
||
key('o', KeyModifiers::ALT | KeyModifiers::SHIFT),
|
||
"the Shift layer keeps its Shift"
|
||
);
|
||
assert_eq!(
|
||
normalize(key('Ø', KeyModifiers::ALT | KeyModifiers::SHIFT)),
|
||
key('o', KeyModifiers::ALT | KeyModifiers::SHIFT),
|
||
"including when the terminal already said so"
|
||
);
|
||
}
|
||
|
||
/// The whole Option layer of the "ABC" layout, as macOS's Keyboard Viewer shows it: every key
|
||
/// that types a character reads back to that key. Written out here rather than derived, so a
|
||
/// row lost from the table is a failure rather than a key that quietly stops working.
|
||
#[test]
|
||
fn every_option_key_on_the_abc_layout_reads_back() {
|
||
let plain = "å a ∫ b ç c ∂ d ƒ f © g ˙ h ∆ j ˚ k ¬ l µ m ø o π p œ q ® r ß s † t √ v ∑ w \
|
||
≈ x ¥ y Ω z ¡ 1 ™ 2 £ 3 ¢ 4 ∞ 5 § 6 ¶ 7 • 8 ª 9 º 0 – - ≠ = “ [ ‘ ] « \\ \
|
||
… ; æ ' ≤ , ≥ . ÷ /";
|
||
let shifted = "Å a ı b Ç c Î d ´ e Ï f ˝ g Ó h ˆ i Ô j \u{f8ff} k Ò l  m ˜ n Ø o ∏ p \
|
||
Œ q ‰ r Í s ˇ t ¨ u ◊ v „ w ˛ x Á y ¸ z";
|
||
for (layer, modifiers) in
|
||
[(plain, KeyModifiers::ALT), (shifted, KeyModifiers::ALT | KeyModifiers::SHIFT)]
|
||
{
|
||
let pairs: Vec<&str> = layer.split_whitespace().collect();
|
||
for pair in pairs.chunks(2) {
|
||
let typed = pair[0].chars().next().expect("a character");
|
||
let base = pair[1].chars().next().expect("a key");
|
||
assert_eq!(
|
||
normalize(key(typed, KeyModifiers::ALT)),
|
||
key(base, modifiers),
|
||
"{typed}"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Typed without Alt it is a character someone meant, from a layout that has it on a key.
|
||
#[test]
|
||
fn a_character_typed_without_alt_is_left_alone() {
|
||
assert_eq!(normalize(key('ø', KeyModifiers::NONE)), key('ø', KeyModifiers::NONE));
|
||
assert_eq!(normalize(key('é', KeyModifiers::ALT)), key('é', KeyModifiers::ALT));
|
||
assert_eq!(normalize(key('o', KeyModifiers::ALT)), key('o', KeyModifiers::ALT));
|
||
}
|
||
}
|