1use anyhow::{Context as _, Result};
2use collections::{BTreeMap, HashMap, IndexMap};
3use fs::Fs;
4use gpui::{
5 Action, ActionBuildError, App, InvalidKeystrokeError, KEYSTROKE_PARSE_EXPECTED_MESSAGE,
6 KeyBinding, KeyBindingContextPredicate, KeyBindingMetaIndex, Keystroke, NoAction, SharedString,
7};
8use schemars::{JsonSchema, json_schema};
9use serde::Deserialize;
10use serde_json::{Value, json};
11use std::borrow::Cow;
12use std::{any::TypeId, fmt::Write, rc::Rc, sync::Arc, sync::LazyLock};
13use util::{
14 asset_str,
15 markdown::{MarkdownEscaped, MarkdownInlineCode, MarkdownString},
16};
17
18use crate::{
19 SettingsAssets, append_top_level_array_value_in_json_text, parse_json_with_comments,
20 replace_top_level_array_value_in_json_text,
21};
22
23pub trait KeyBindingValidator: Send + Sync {
24 fn action_type_id(&self) -> TypeId;
25 fn validate(&self, binding: &KeyBinding) -> Result<(), MarkdownString>;
26}
27
28pub struct KeyBindingValidatorRegistration(pub fn() -> Box<dyn KeyBindingValidator>);
29
30inventory::collect!(KeyBindingValidatorRegistration);
31
32pub(crate) static KEY_BINDING_VALIDATORS: LazyLock<BTreeMap<TypeId, Box<dyn KeyBindingValidator>>> =
33 LazyLock::new(|| {
34 let mut validators = BTreeMap::new();
35 for validator_registration in inventory::iter::<KeyBindingValidatorRegistration> {
36 let validator = validator_registration.0();
37 validators.insert(validator.action_type_id(), validator);
38 }
39 validators
40 });
41
42// Note that the doc comments on these are shown by json-language-server when editing the keymap, so
43// they should be considered user-facing documentation. Documentation is not handled well with
44// schemars-0.8 - when there are newlines, it is rendered as plaintext (see
45// https://github.com/GREsau/schemars/issues/38#issuecomment-2282883519). So for now these docs
46// avoid newlines.
47//
48// TODO: Update to schemars-1.0 once it's released, and add more docs as newlines would be
49// supported. Tracking issue is https://github.com/GREsau/schemars/issues/112.
50
51/// Keymap configuration consisting of sections. Each section may have a context predicate which
52/// determines whether its bindings are used.
53#[derive(Debug, Deserialize, Default, Clone, JsonSchema)]
54#[serde(transparent)]
55pub struct KeymapFile(Vec<KeymapSection>);
56
57/// Keymap section which binds keystrokes to actions.
58#[derive(Debug, Deserialize, Default, Clone, JsonSchema)]
59pub struct KeymapSection {
60 /// Determines when these bindings are active. When just a name is provided, like `Editor` or
61 /// `Workspace`, the bindings will be active in that context. Boolean expressions like `X && Y`,
62 /// `X || Y`, `!X` are also supported. Some more complex logic including checking OS and the
63 /// current file extension are also supported - see [the
64 /// documentation](https://zed.dev/docs/key-bindings#contexts) for more details.
65 #[serde(default)]
66 pub context: String,
67 /// This option enables specifying keys based on their position on a QWERTY keyboard, by using
68 /// position-equivalent mappings for some non-QWERTY keyboards. This is currently only supported
69 /// on macOS. See the documentation for more details.
70 #[serde(default)]
71 use_key_equivalents: bool,
72 /// This keymap section's bindings, as a JSON object mapping keystrokes to actions. The
73 /// keystrokes key is a string representing a sequence of keystrokes to type, where the
74 /// keystrokes are separated by whitespace. Each keystroke is a sequence of modifiers (`ctrl`,
75 /// `alt`, `shift`, `fn`, `cmd`, `super`, or `win`) followed by a key, separated by `-`. The
76 /// order of bindings does matter. When the same keystrokes are bound at the same context depth,
77 /// the binding that occurs later in the file is preferred. For displaying keystrokes in the UI,
78 /// the later binding for the same action is preferred.
79 #[serde(default)]
80 bindings: Option<IndexMap<String, KeymapAction>>,
81 #[serde(flatten)]
82 unrecognized_fields: IndexMap<String, Value>,
83 // This struct intentionally uses permissive types for its fields, rather than validating during
84 // deserialization. The purpose of this is to allow loading the portion of the keymap that doesn't
85 // have errors. The downside of this is that the errors are not reported with line+column info.
86 // Unfortunately the implementations of the `Spanned` types for preserving this information are
87 // highly inconvenient (`serde_spanned`) and in some cases don't work at all here
88 // (`json_spanned_>value`). Serde should really have builtin support for this.
89}
90
91impl KeymapSection {
92 pub fn bindings(&self) -> impl DoubleEndedIterator<Item = (&String, &KeymapAction)> {
93 self.bindings.iter().flatten()
94 }
95}
96
97/// Keymap action as a JSON value, since it can either be null for no action, or the name of the
98/// action, or an array of the name of the action and the action input.
99///
100/// Unlike the other json types involved in keymaps (including actions), this doc-comment will not
101/// be included in the generated JSON schema, as it manually defines its `JsonSchema` impl. The
102/// actual schema used for it is automatically generated in `KeymapFile::generate_json_schema`.
103#[derive(Debug, Deserialize, Default, Clone)]
104#[serde(transparent)]
105pub struct KeymapAction(Value);
106
107impl std::fmt::Display for KeymapAction {
108 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
109 match &self.0 {
110 Value::String(s) => write!(f, "{}", s),
111 Value::Array(arr) => {
112 let strings: Vec<String> = arr.iter().map(|v| v.to_string()).collect();
113 write!(f, "{}", strings.join(", "))
114 }
115 _ => write!(f, "{}", self.0),
116 }
117 }
118}
119
120impl JsonSchema for KeymapAction {
121 /// This is used when generating the JSON schema for the `KeymapAction` type, so that it can
122 /// reference the keymap action schema.
123 fn schema_name() -> Cow<'static, str> {
124 "KeymapAction".into()
125 }
126
127 /// This schema will be replaced with the full action schema in
128 /// `KeymapFile::generate_json_schema`.
129 fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
130 json_schema!(true)
131 }
132}
133
134#[derive(Debug)]
135#[must_use]
136pub enum KeymapFileLoadResult {
137 Success {
138 key_bindings: Vec<KeyBinding>,
139 },
140 SomeFailedToLoad {
141 key_bindings: Vec<KeyBinding>,
142 error_message: MarkdownString,
143 },
144 JsonParseFailure {
145 error: anyhow::Error,
146 },
147}
148
149impl KeymapFile {
150 pub fn parse(content: &str) -> anyhow::Result<Self> {
151 parse_json_with_comments::<Self>(content)
152 }
153
154 pub fn load_asset(
155 asset_path: &str,
156 source: Option<KeybindSource>,
157 cx: &App,
158 ) -> anyhow::Result<Vec<KeyBinding>> {
159 match Self::load(asset_str::<SettingsAssets>(asset_path).as_ref(), cx) {
160 KeymapFileLoadResult::Success { mut key_bindings } => match source {
161 Some(source) => Ok({
162 for key_binding in &mut key_bindings {
163 key_binding.set_meta(source.meta());
164 }
165 key_bindings
166 }),
167 None => Ok(key_bindings),
168 },
169 KeymapFileLoadResult::SomeFailedToLoad { error_message, .. } => {
170 anyhow::bail!("Error loading built-in keymap \"{asset_path}\": {error_message}",)
171 }
172 KeymapFileLoadResult::JsonParseFailure { error } => {
173 anyhow::bail!("JSON parse error in built-in keymap \"{asset_path}\": {error}")
174 }
175 }
176 }
177
178 #[cfg(feature = "test-support")]
179 pub fn load_asset_allow_partial_failure(
180 asset_path: &str,
181 cx: &App,
182 ) -> anyhow::Result<Vec<KeyBinding>> {
183 match Self::load(asset_str::<SettingsAssets>(asset_path).as_ref(), cx) {
184 KeymapFileLoadResult::SomeFailedToLoad {
185 key_bindings,
186 error_message,
187 ..
188 } if key_bindings.is_empty() => {
189 anyhow::bail!("Error loading built-in keymap \"{asset_path}\": {error_message}",)
190 }
191 KeymapFileLoadResult::Success { key_bindings, .. }
192 | KeymapFileLoadResult::SomeFailedToLoad { key_bindings, .. } => Ok(key_bindings),
193 KeymapFileLoadResult::JsonParseFailure { error } => {
194 anyhow::bail!("JSON parse error in built-in keymap \"{asset_path}\": {error}")
195 }
196 }
197 }
198
199 #[cfg(feature = "test-support")]
200 pub fn load_panic_on_failure(content: &str, cx: &App) -> Vec<KeyBinding> {
201 match Self::load(content, cx) {
202 KeymapFileLoadResult::Success { key_bindings, .. } => key_bindings,
203 KeymapFileLoadResult::SomeFailedToLoad { error_message, .. } => {
204 panic!("{error_message}");
205 }
206 KeymapFileLoadResult::JsonParseFailure { error } => {
207 panic!("JSON parse error: {error}");
208 }
209 }
210 }
211
212 pub fn load(content: &str, cx: &App) -> KeymapFileLoadResult {
213 let key_equivalents =
214 crate::key_equivalents::get_key_equivalents(cx.keyboard_layout().id());
215
216 if content.is_empty() {
217 return KeymapFileLoadResult::Success {
218 key_bindings: Vec::new(),
219 };
220 }
221 let keymap_file = match Self::parse(content) {
222 Ok(keymap_file) => keymap_file,
223 Err(error) => {
224 return KeymapFileLoadResult::JsonParseFailure { error };
225 }
226 };
227
228 // Accumulate errors in order to support partial load of user keymap in the presence of
229 // errors in context and binding parsing.
230 let mut errors = Vec::new();
231 let mut key_bindings = Vec::new();
232
233 for KeymapSection {
234 context,
235 use_key_equivalents,
236 bindings,
237 unrecognized_fields,
238 } in keymap_file.0.iter()
239 {
240 let context_predicate: Option<Rc<KeyBindingContextPredicate>> = if context.is_empty() {
241 None
242 } else {
243 match KeyBindingContextPredicate::parse(context) {
244 Ok(context_predicate) => Some(context_predicate.into()),
245 Err(err) => {
246 // Leading space is to separate from the message indicating which section
247 // the error occurred in.
248 errors.push((
249 context,
250 format!(" Parse error in section `context` field: {}", err),
251 ));
252 continue;
253 }
254 }
255 };
256
257 let key_equivalents = if *use_key_equivalents {
258 key_equivalents.as_ref()
259 } else {
260 None
261 };
262
263 let mut section_errors = String::new();
264
265 if !unrecognized_fields.is_empty() {
266 write!(
267 section_errors,
268 "\n\n - Unrecognized fields: {}",
269 MarkdownInlineCode(&format!("{:?}", unrecognized_fields.keys()))
270 )
271 .unwrap();
272 }
273
274 if let Some(bindings) = bindings {
275 for (keystrokes, action) in bindings {
276 let result = Self::load_keybinding(
277 keystrokes,
278 action,
279 context_predicate.clone(),
280 key_equivalents,
281 cx,
282 );
283 match result {
284 Ok(key_binding) => {
285 key_bindings.push(key_binding);
286 }
287 Err(err) => {
288 let mut lines = err.lines();
289 let mut indented_err = lines.next().unwrap().to_string();
290 for line in lines {
291 indented_err.push_str(" ");
292 indented_err.push_str(line);
293 indented_err.push_str("\n");
294 }
295 write!(
296 section_errors,
297 "\n\n- In binding {}, {indented_err}",
298 MarkdownInlineCode(&format!("\"{}\"", keystrokes))
299 )
300 .unwrap();
301 }
302 }
303 }
304 }
305
306 if !section_errors.is_empty() {
307 errors.push((context, section_errors))
308 }
309 }
310
311 if errors.is_empty() {
312 KeymapFileLoadResult::Success { key_bindings }
313 } else {
314 let mut error_message = "Errors in user keymap file.\n".to_owned();
315 for (context, section_errors) in errors {
316 if context.is_empty() {
317 let _ = write!(error_message, "\n\nIn section without context predicate:");
318 } else {
319 let _ = write!(
320 error_message,
321 "\n\nIn section with {}:",
322 MarkdownInlineCode(&format!("context = \"{}\"", context))
323 );
324 }
325 let _ = write!(error_message, "{section_errors}");
326 }
327 KeymapFileLoadResult::SomeFailedToLoad {
328 key_bindings,
329 error_message: MarkdownString(error_message),
330 }
331 }
332 }
333
334 fn load_keybinding(
335 keystrokes: &str,
336 action: &KeymapAction,
337 context: Option<Rc<KeyBindingContextPredicate>>,
338 key_equivalents: Option<&HashMap<char, char>>,
339 cx: &App,
340 ) -> std::result::Result<KeyBinding, String> {
341 let (build_result, action_input_string) = match &action.0 {
342 Value::Array(items) => {
343 if items.len() != 2 {
344 return Err(format!(
345 "expected two-element array of `[name, input]`. \
346 Instead found {}.",
347 MarkdownInlineCode(&action.0.to_string())
348 ));
349 }
350 let serde_json::Value::String(ref name) = items[0] else {
351 return Err(format!(
352 "expected two-element array of `[name, input]`, \
353 but the first element is not a string in {}.",
354 MarkdownInlineCode(&action.0.to_string())
355 ));
356 };
357 let action_input = items[1].clone();
358 let action_input_string = action_input.to_string();
359 (
360 cx.build_action(&name, Some(action_input)),
361 Some(action_input_string),
362 )
363 }
364 Value::String(name) => (cx.build_action(&name, None), None),
365 Value::Null => (Ok(NoAction.boxed_clone()), None),
366 _ => {
367 return Err(format!(
368 "expected two-element array of `[name, input]`. \
369 Instead found {}.",
370 MarkdownInlineCode(&action.0.to_string())
371 ));
372 }
373 };
374
375 let action = match build_result {
376 Ok(action) => action,
377 Err(ActionBuildError::NotFound { name }) => {
378 return Err(format!(
379 "didn't find an action named {}.",
380 MarkdownInlineCode(&format!("\"{}\"", &name))
381 ));
382 }
383 Err(ActionBuildError::BuildError { name, error }) => match action_input_string {
384 Some(action_input_string) => {
385 return Err(format!(
386 "can't build {} action from input value {}: {}",
387 MarkdownInlineCode(&format!("\"{}\"", &name)),
388 MarkdownInlineCode(&action_input_string),
389 MarkdownEscaped(&error.to_string())
390 ));
391 }
392 None => {
393 return Err(format!(
394 "can't build {} action - it requires input data via [name, input]: {}",
395 MarkdownInlineCode(&format!("\"{}\"", &name)),
396 MarkdownEscaped(&error.to_string())
397 ));
398 }
399 },
400 };
401
402 let key_binding = match KeyBinding::load(
403 keystrokes,
404 action,
405 context,
406 key_equivalents,
407 action_input_string.map(SharedString::from),
408 ) {
409 Ok(key_binding) => key_binding,
410 Err(InvalidKeystrokeError { keystroke }) => {
411 return Err(format!(
412 "invalid keystroke {}. {}",
413 MarkdownInlineCode(&format!("\"{}\"", &keystroke)),
414 KEYSTROKE_PARSE_EXPECTED_MESSAGE
415 ));
416 }
417 };
418
419 if let Some(validator) = KEY_BINDING_VALIDATORS.get(&key_binding.action().type_id()) {
420 match validator.validate(&key_binding) {
421 Ok(()) => Ok(key_binding),
422 Err(error) => Err(error.0),
423 }
424 } else {
425 Ok(key_binding)
426 }
427 }
428
429 /// Creates a JSON schema generator, suitable for generating json schemas
430 /// for actions
431 pub fn action_schema_generator() -> schemars::SchemaGenerator {
432 schemars::generate::SchemaSettings::draft2019_09().into_generator()
433 }
434
435 pub fn generate_json_schema_for_registered_actions(cx: &mut App) -> Value {
436 // instead of using DefaultDenyUnknownFields, actions typically use
437 // `#[serde(deny_unknown_fields)]` so that these cases are reported as parse failures. This
438 // is because the rest of the keymap will still load in these cases, whereas other settings
439 // files would not.
440 let mut generator = Self::action_schema_generator();
441
442 let action_schemas = cx.action_schemas(&mut generator);
443 let deprecations = cx.deprecated_actions_to_preferred_actions();
444 let deprecation_messages = cx.action_deprecation_messages();
445 KeymapFile::generate_json_schema(
446 generator,
447 action_schemas,
448 deprecations,
449 deprecation_messages,
450 )
451 }
452
453 fn generate_json_schema(
454 mut generator: schemars::SchemaGenerator,
455 action_schemas: Vec<(&'static str, Option<schemars::Schema>)>,
456 deprecations: &HashMap<&'static str, &'static str>,
457 deprecation_messages: &HashMap<&'static str, &'static str>,
458 ) -> serde_json::Value {
459 fn add_deprecation(schema: &mut schemars::Schema, message: String) {
460 schema.insert(
461 // deprecationMessage is not part of the JSON Schema spec, but
462 // json-language-server recognizes it.
463 "deprecationMessage".to_string(),
464 Value::String(message),
465 );
466 }
467
468 fn add_deprecation_preferred_name(schema: &mut schemars::Schema, new_name: &str) {
469 add_deprecation(schema, format!("Deprecated, use {new_name}"));
470 }
471
472 fn add_description(schema: &mut schemars::Schema, description: String) {
473 schema.insert("description".to_string(), Value::String(description));
474 }
475
476 let empty_object = json_schema!({
477 "type": "object"
478 });
479
480 // This is a workaround for a json-language-server issue where it matches the first
481 // alternative that matches the value's shape and uses that for documentation.
482 //
483 // In the case of the array validations, it would even provide an error saying that the name
484 // must match the name of the first alternative.
485 let mut plain_action = json_schema!({
486 "type": "string",
487 "const": ""
488 });
489 let no_action_message = "No action named this.";
490 add_description(&mut plain_action, no_action_message.to_owned());
491 add_deprecation(&mut plain_action, no_action_message.to_owned());
492
493 let mut matches_action_name = json_schema!({
494 "const": ""
495 });
496 let no_action_message_input = "No action named this that takes input.";
497 add_description(&mut matches_action_name, no_action_message_input.to_owned());
498 add_deprecation(&mut matches_action_name, no_action_message_input.to_owned());
499
500 let action_with_input = json_schema!({
501 "type": "array",
502 "items": [
503 matches_action_name,
504 true
505 ],
506 "minItems": 2,
507 "maxItems": 2
508 });
509 let mut keymap_action_alternatives = vec![plain_action, action_with_input];
510
511 for (name, action_schema) in action_schemas.into_iter() {
512 let description = action_schema.as_ref().and_then(|schema| {
513 schema
514 .as_object()
515 .and_then(|obj| obj.get("description"))
516 .and_then(|v| v.as_str())
517 .map(|s| s.to_string())
518 });
519
520 let deprecation = if name == NoAction.name() {
521 Some("null")
522 } else {
523 deprecations.get(name).copied()
524 };
525
526 // Add an alternative for plain action names.
527 let mut plain_action = json_schema!({
528 "type": "string",
529 "const": name
530 });
531 if let Some(message) = deprecation_messages.get(name) {
532 add_deprecation(&mut plain_action, message.to_string());
533 } else if let Some(new_name) = deprecation {
534 add_deprecation_preferred_name(&mut plain_action, new_name);
535 }
536 if let Some(desc) = description.clone() {
537 add_description(&mut plain_action, desc);
538 }
539 keymap_action_alternatives.push(plain_action);
540
541 // Add an alternative for actions with data specified as a [name, data] array.
542 //
543 // When a struct with no deserializable fields is added by deriving `Action`, an empty
544 // object schema is produced. The action should be invoked without data in this case.
545 if let Some(schema) = action_schema {
546 if schema != empty_object {
547 let mut matches_action_name = json_schema!({
548 "const": name
549 });
550 if let Some(desc) = description.clone() {
551 add_description(&mut matches_action_name, desc);
552 }
553 if let Some(message) = deprecation_messages.get(name) {
554 add_deprecation(&mut matches_action_name, message.to_string());
555 } else if let Some(new_name) = deprecation {
556 add_deprecation_preferred_name(&mut matches_action_name, new_name);
557 }
558 let action_with_input = json_schema!({
559 "type": "array",
560 "items": [matches_action_name, schema],
561 "minItems": 2,
562 "maxItems": 2
563 });
564 keymap_action_alternatives.push(action_with_input);
565 }
566 }
567 }
568
569 // Placing null first causes json-language-server to default assuming actions should be
570 // null, so place it last.
571 keymap_action_alternatives.push(json_schema!({
572 "type": "null"
573 }));
574
575 // The `KeymapSection` schema will reference the `KeymapAction` schema by name, so setting
576 // the definition of `KeymapAction` results in the full action schema being used.
577 generator.definitions_mut().insert(
578 KeymapAction::schema_name().to_string(),
579 json!({
580 "oneOf": keymap_action_alternatives
581 }),
582 );
583
584 generator.root_schema_for::<KeymapFile>().to_value()
585 }
586
587 pub fn sections(&self) -> impl DoubleEndedIterator<Item = &KeymapSection> {
588 self.0.iter()
589 }
590
591 pub async fn load_keymap_file(fs: &Arc<dyn Fs>) -> Result<String> {
592 match fs.load(paths::keymap_file()).await {
593 result @ Ok(_) => result,
594 Err(err) => {
595 if let Some(e) = err.downcast_ref::<std::io::Error>() {
596 if e.kind() == std::io::ErrorKind::NotFound {
597 return Ok(crate::initial_keymap_content().to_string());
598 }
599 }
600 Err(err)
601 }
602 }
603 }
604
605 pub fn update_keybinding<'a>(
606 mut operation: KeybindUpdateOperation<'a>,
607 mut keymap_contents: String,
608 tab_size: usize,
609 ) -> Result<String> {
610 match operation {
611 // if trying to replace a keybinding that is not user-defined, treat it as an add operation
612 KeybindUpdateOperation::Replace {
613 target_keybind_source: target_source,
614 source,
615 ..
616 } if target_source != KeybindSource::User => {
617 operation = KeybindUpdateOperation::Add(source);
618 }
619 // if trying to remove a keybinding that is not user-defined, treat it as creating a binding
620 // that binds it to `zed::NoAction`
621 KeybindUpdateOperation::Remove {
622 mut target,
623 target_keybind_source,
624 } if target_keybind_source != KeybindSource::User => {
625 target.action_name = gpui::NoAction.name();
626 target.action_arguments.take();
627 operation = KeybindUpdateOperation::Add(target);
628 }
629 _ => {}
630 }
631
632 // Sanity check that keymap contents are valid, even though we only use it for Replace.
633 // We don't want to modify the file if it's invalid.
634 let keymap = Self::parse(&keymap_contents).context("Failed to parse keymap")?;
635
636 if let KeybindUpdateOperation::Remove { target, .. } = operation {
637 let target_action_value = target
638 .action_value()
639 .context("Failed to generate target action JSON value")?;
640 let Some((index, keystrokes_str)) =
641 find_binding(&keymap, &target, &target_action_value)
642 else {
643 anyhow::bail!("Failed to find keybinding to remove");
644 };
645 let is_only_binding = keymap.0[index]
646 .bindings
647 .as_ref()
648 .map_or(true, |bindings| bindings.len() == 1);
649 let key_path: &[&str] = if is_only_binding {
650 &[]
651 } else {
652 &["bindings", keystrokes_str]
653 };
654 let (replace_range, replace_value) = replace_top_level_array_value_in_json_text(
655 &keymap_contents,
656 key_path,
657 None,
658 None,
659 index,
660 tab_size,
661 )
662 .context("Failed to remove keybinding")?;
663 keymap_contents.replace_range(replace_range, &replace_value);
664 return Ok(keymap_contents);
665 }
666
667 if let KeybindUpdateOperation::Replace { source, target, .. } = operation {
668 let target_action_value = target
669 .action_value()
670 .context("Failed to generate target action JSON value")?;
671 let source_action_value = source
672 .action_value()
673 .context("Failed to generate source action JSON value")?;
674
675 if let Some((index, keystrokes_str)) =
676 find_binding(&keymap, &target, &target_action_value)
677 {
678 if target.context == source.context {
679 // if we are only changing the keybinding (common case)
680 // not the context, etc. Then just update the binding in place
681
682 let (replace_range, replace_value) =
683 replace_top_level_array_value_in_json_text(
684 &keymap_contents,
685 &["bindings", keystrokes_str],
686 Some(&source_action_value),
687 Some(&source.keystrokes_unparsed()),
688 index,
689 tab_size,
690 )
691 .context("Failed to replace keybinding")?;
692 keymap_contents.replace_range(replace_range, &replace_value);
693
694 return Ok(keymap_contents);
695 } else if keymap.0[index]
696 .bindings
697 .as_ref()
698 .map_or(true, |bindings| bindings.len() == 1)
699 {
700 // if we are replacing the only binding in the section,
701 // just update the section in place, updating the context
702 // and the binding
703
704 let (replace_range, replace_value) =
705 replace_top_level_array_value_in_json_text(
706 &keymap_contents,
707 &["bindings", keystrokes_str],
708 Some(&source_action_value),
709 Some(&source.keystrokes_unparsed()),
710 index,
711 tab_size,
712 )
713 .context("Failed to replace keybinding")?;
714 keymap_contents.replace_range(replace_range, &replace_value);
715
716 let (replace_range, replace_value) =
717 replace_top_level_array_value_in_json_text(
718 &keymap_contents,
719 &["context"],
720 source.context.map(Into::into).as_ref(),
721 None,
722 index,
723 tab_size,
724 )
725 .context("Failed to replace keybinding")?;
726 keymap_contents.replace_range(replace_range, &replace_value);
727 return Ok(keymap_contents);
728 } else {
729 // if we are replacing one of multiple bindings in a section
730 // with a context change, remove the existing binding from the
731 // section, then treat this operation as an add operation of the
732 // new binding with the updated context.
733
734 let (replace_range, replace_value) =
735 replace_top_level_array_value_in_json_text(
736 &keymap_contents,
737 &["bindings", keystrokes_str],
738 None,
739 None,
740 index,
741 tab_size,
742 )
743 .context("Failed to replace keybinding")?;
744 keymap_contents.replace_range(replace_range, &replace_value);
745 operation = KeybindUpdateOperation::Add(source);
746 }
747 } else {
748 log::warn!(
749 "Failed to find keybinding to update `{:?} -> {}` creating new binding for `{:?} -> {}` instead",
750 target.keystrokes,
751 target_action_value,
752 source.keystrokes,
753 source_action_value,
754 );
755 operation = KeybindUpdateOperation::Add(source);
756 }
757 }
758
759 if let KeybindUpdateOperation::Add(keybinding) = operation {
760 let mut value = serde_json::Map::with_capacity(4);
761 if let Some(context) = keybinding.context {
762 value.insert("context".to_string(), context.into());
763 }
764 if keybinding.use_key_equivalents {
765 value.insert("use_key_equivalents".to_string(), true.into());
766 }
767
768 value.insert("bindings".to_string(), {
769 let mut bindings = serde_json::Map::new();
770 let action = keybinding.action_value()?;
771 bindings.insert(keybinding.keystrokes_unparsed(), action);
772 bindings.into()
773 });
774
775 let (replace_range, replace_value) = append_top_level_array_value_in_json_text(
776 &keymap_contents,
777 &value.into(),
778 tab_size,
779 )?;
780 keymap_contents.replace_range(replace_range, &replace_value);
781 }
782 return Ok(keymap_contents);
783
784 fn find_binding<'a, 'b>(
785 keymap: &'b KeymapFile,
786 target: &KeybindUpdateTarget<'a>,
787 target_action_value: &Value,
788 ) -> Option<(usize, &'b str)> {
789 let target_context_parsed =
790 KeyBindingContextPredicate::parse(target.context.unwrap_or("")).ok();
791 for (index, section) in keymap.sections().enumerate() {
792 let section_context_parsed =
793 KeyBindingContextPredicate::parse(§ion.context).ok();
794 if section_context_parsed != target_context_parsed {
795 continue;
796 }
797 if section.use_key_equivalents != target.use_key_equivalents {
798 continue;
799 }
800 let Some(bindings) = §ion.bindings else {
801 continue;
802 };
803 for (keystrokes_str, action) in bindings {
804 let Ok(keystrokes) = keystrokes_str
805 .split_whitespace()
806 .map(Keystroke::parse)
807 .collect::<Result<Vec<_>, _>>()
808 else {
809 continue;
810 };
811 if keystrokes.len() != target.keystrokes.len()
812 || !keystrokes
813 .iter()
814 .zip(target.keystrokes)
815 .all(|(a, b)| a.should_match(b))
816 {
817 continue;
818 }
819 if &action.0 != target_action_value {
820 continue;
821 }
822 return Some((index, &keystrokes_str));
823 }
824 }
825 None
826 }
827 }
828}
829
830pub enum KeybindUpdateOperation<'a> {
831 Replace {
832 /// Describes the keybind to create
833 source: KeybindUpdateTarget<'a>,
834 /// Describes the keybind to remove
835 target: KeybindUpdateTarget<'a>,
836 target_keybind_source: KeybindSource,
837 },
838 Add(KeybindUpdateTarget<'a>),
839 Remove {
840 target: KeybindUpdateTarget<'a>,
841 target_keybind_source: KeybindSource,
842 },
843}
844
845#[derive(Debug)]
846pub struct KeybindUpdateTarget<'a> {
847 pub context: Option<&'a str>,
848 pub keystrokes: &'a [Keystroke],
849 pub action_name: &'a str,
850 pub use_key_equivalents: bool,
851 pub action_arguments: Option<&'a str>,
852}
853
854impl<'a> KeybindUpdateTarget<'a> {
855 fn action_value(&self) -> Result<Value> {
856 let action_name: Value = self.action_name.into();
857 let value = match self.action_arguments {
858 Some(args) => {
859 let args = serde_json::from_str::<Value>(args)
860 .context("Failed to parse action arguments as JSON")?;
861 serde_json::json!([action_name, args])
862 }
863 None => action_name,
864 };
865 return Ok(value);
866 }
867
868 fn keystrokes_unparsed(&self) -> String {
869 let mut keystrokes = String::with_capacity(self.keystrokes.len() * 8);
870 for keystroke in self.keystrokes {
871 keystrokes.push_str(&keystroke.unparse());
872 keystrokes.push(' ');
873 }
874 keystrokes.pop();
875 keystrokes
876 }
877}
878
879#[derive(Clone, Copy, PartialEq, Eq)]
880pub enum KeybindSource {
881 User,
882 Default,
883 Base,
884 Vim,
885}
886
887impl KeybindSource {
888 const BASE: KeyBindingMetaIndex = KeyBindingMetaIndex(0);
889 const DEFAULT: KeyBindingMetaIndex = KeyBindingMetaIndex(1);
890 const VIM: KeyBindingMetaIndex = KeyBindingMetaIndex(2);
891 const USER: KeyBindingMetaIndex = KeyBindingMetaIndex(3);
892
893 pub fn name(&self) -> &'static str {
894 match self {
895 KeybindSource::User => "User",
896 KeybindSource::Default => "Default",
897 KeybindSource::Base => "Base",
898 KeybindSource::Vim => "Vim",
899 }
900 }
901
902 pub fn meta(&self) -> KeyBindingMetaIndex {
903 match self {
904 KeybindSource::User => Self::USER,
905 KeybindSource::Default => Self::DEFAULT,
906 KeybindSource::Base => Self::BASE,
907 KeybindSource::Vim => Self::VIM,
908 }
909 }
910
911 pub fn from_meta(index: KeyBindingMetaIndex) -> Self {
912 match index {
913 Self::USER => KeybindSource::User,
914 Self::BASE => KeybindSource::Base,
915 Self::DEFAULT => KeybindSource::Default,
916 Self::VIM => KeybindSource::Vim,
917 _ => unreachable!(),
918 }
919 }
920}
921
922impl From<KeyBindingMetaIndex> for KeybindSource {
923 fn from(index: KeyBindingMetaIndex) -> Self {
924 Self::from_meta(index)
925 }
926}
927
928impl From<KeybindSource> for KeyBindingMetaIndex {
929 fn from(source: KeybindSource) -> Self {
930 return source.meta();
931 }
932}
933
934#[cfg(test)]
935mod tests {
936 use unindent::Unindent;
937
938 use crate::{
939 KeybindSource, KeymapFile,
940 keymap_file::{KeybindUpdateOperation, KeybindUpdateTarget},
941 };
942
943 #[test]
944 fn can_deserialize_keymap_with_trailing_comma() {
945 let json = indoc::indoc! {"[
946 // Standard macOS bindings
947 {
948 \"bindings\": {
949 \"up\": \"menu::SelectPrevious\",
950 },
951 },
952 ]
953 "
954 };
955 KeymapFile::parse(json).unwrap();
956 }
957
958 #[test]
959 fn keymap_update() {
960 use gpui::Keystroke;
961
962 zlog::init_test();
963 #[track_caller]
964 fn check_keymap_update(
965 input: impl ToString,
966 operation: KeybindUpdateOperation,
967 expected: impl ToString,
968 ) {
969 let result = KeymapFile::update_keybinding(operation, input.to_string(), 4)
970 .expect("Update succeeded");
971 pretty_assertions::assert_eq!(expected.to_string(), result);
972 }
973
974 #[track_caller]
975 fn parse_keystrokes(keystrokes: &str) -> Vec<Keystroke> {
976 return keystrokes
977 .split(' ')
978 .map(|s| Keystroke::parse(s).expect("Keystrokes valid"))
979 .collect();
980 }
981
982 check_keymap_update(
983 "[]",
984 KeybindUpdateOperation::Add(KeybindUpdateTarget {
985 keystrokes: &parse_keystrokes("ctrl-a"),
986 action_name: "zed::SomeAction",
987 context: None,
988 use_key_equivalents: false,
989 action_arguments: None,
990 }),
991 r#"[
992 {
993 "bindings": {
994 "ctrl-a": "zed::SomeAction"
995 }
996 }
997 ]"#
998 .unindent(),
999 );
1000
1001 check_keymap_update(
1002 r#"[
1003 {
1004 "bindings": {
1005 "ctrl-a": "zed::SomeAction"
1006 }
1007 }
1008 ]"#
1009 .unindent(),
1010 KeybindUpdateOperation::Add(KeybindUpdateTarget {
1011 keystrokes: &parse_keystrokes("ctrl-b"),
1012 action_name: "zed::SomeOtherAction",
1013 context: None,
1014 use_key_equivalents: false,
1015 action_arguments: None,
1016 }),
1017 r#"[
1018 {
1019 "bindings": {
1020 "ctrl-a": "zed::SomeAction"
1021 }
1022 },
1023 {
1024 "bindings": {
1025 "ctrl-b": "zed::SomeOtherAction"
1026 }
1027 }
1028 ]"#
1029 .unindent(),
1030 );
1031
1032 check_keymap_update(
1033 r#"[
1034 {
1035 "bindings": {
1036 "ctrl-a": "zed::SomeAction"
1037 }
1038 }
1039 ]"#
1040 .unindent(),
1041 KeybindUpdateOperation::Add(KeybindUpdateTarget {
1042 keystrokes: &parse_keystrokes("ctrl-b"),
1043 action_name: "zed::SomeOtherAction",
1044 context: None,
1045 use_key_equivalents: false,
1046 action_arguments: Some(r#"{"foo": "bar"}"#),
1047 }),
1048 r#"[
1049 {
1050 "bindings": {
1051 "ctrl-a": "zed::SomeAction"
1052 }
1053 },
1054 {
1055 "bindings": {
1056 "ctrl-b": [
1057 "zed::SomeOtherAction",
1058 {
1059 "foo": "bar"
1060 }
1061 ]
1062 }
1063 }
1064 ]"#
1065 .unindent(),
1066 );
1067
1068 check_keymap_update(
1069 r#"[
1070 {
1071 "bindings": {
1072 "ctrl-a": "zed::SomeAction"
1073 }
1074 }
1075 ]"#
1076 .unindent(),
1077 KeybindUpdateOperation::Add(KeybindUpdateTarget {
1078 keystrokes: &parse_keystrokes("ctrl-b"),
1079 action_name: "zed::SomeOtherAction",
1080 context: Some("Zed > Editor && some_condition = true"),
1081 use_key_equivalents: true,
1082 action_arguments: Some(r#"{"foo": "bar"}"#),
1083 }),
1084 r#"[
1085 {
1086 "bindings": {
1087 "ctrl-a": "zed::SomeAction"
1088 }
1089 },
1090 {
1091 "context": "Zed > Editor && some_condition = true",
1092 "use_key_equivalents": true,
1093 "bindings": {
1094 "ctrl-b": [
1095 "zed::SomeOtherAction",
1096 {
1097 "foo": "bar"
1098 }
1099 ]
1100 }
1101 }
1102 ]"#
1103 .unindent(),
1104 );
1105
1106 check_keymap_update(
1107 r#"[
1108 {
1109 "bindings": {
1110 "ctrl-a": "zed::SomeAction"
1111 }
1112 }
1113 ]"#
1114 .unindent(),
1115 KeybindUpdateOperation::Replace {
1116 target: KeybindUpdateTarget {
1117 keystrokes: &parse_keystrokes("ctrl-a"),
1118 action_name: "zed::SomeAction",
1119 context: None,
1120 use_key_equivalents: false,
1121 action_arguments: None,
1122 },
1123 source: KeybindUpdateTarget {
1124 keystrokes: &parse_keystrokes("ctrl-b"),
1125 action_name: "zed::SomeOtherAction",
1126 context: None,
1127 use_key_equivalents: false,
1128 action_arguments: Some(r#"{"foo": "bar"}"#),
1129 },
1130 target_keybind_source: KeybindSource::Base,
1131 },
1132 r#"[
1133 {
1134 "bindings": {
1135 "ctrl-a": "zed::SomeAction"
1136 }
1137 },
1138 {
1139 "bindings": {
1140 "ctrl-b": [
1141 "zed::SomeOtherAction",
1142 {
1143 "foo": "bar"
1144 }
1145 ]
1146 }
1147 }
1148 ]"#
1149 .unindent(),
1150 );
1151
1152 check_keymap_update(
1153 r#"[
1154 {
1155 "bindings": {
1156 "a": "zed::SomeAction"
1157 }
1158 }
1159 ]"#
1160 .unindent(),
1161 KeybindUpdateOperation::Replace {
1162 target: KeybindUpdateTarget {
1163 keystrokes: &parse_keystrokes("a"),
1164 action_name: "zed::SomeAction",
1165 context: None,
1166 use_key_equivalents: false,
1167 action_arguments: None,
1168 },
1169 source: KeybindUpdateTarget {
1170 keystrokes: &parse_keystrokes("ctrl-b"),
1171 action_name: "zed::SomeOtherAction",
1172 context: None,
1173 use_key_equivalents: false,
1174 action_arguments: Some(r#"{"foo": "bar"}"#),
1175 },
1176 target_keybind_source: KeybindSource::User,
1177 },
1178 r#"[
1179 {
1180 "bindings": {
1181 "ctrl-b": [
1182 "zed::SomeOtherAction",
1183 {
1184 "foo": "bar"
1185 }
1186 ]
1187 }
1188 }
1189 ]"#
1190 .unindent(),
1191 );
1192
1193 check_keymap_update(
1194 r#"[
1195 {
1196 "bindings": {
1197 "ctrl-a": "zed::SomeAction"
1198 }
1199 }
1200 ]"#
1201 .unindent(),
1202 KeybindUpdateOperation::Replace {
1203 target: KeybindUpdateTarget {
1204 keystrokes: &parse_keystrokes("ctrl-a"),
1205 action_name: "zed::SomeNonexistentAction",
1206 context: None,
1207 use_key_equivalents: false,
1208 action_arguments: None,
1209 },
1210 source: KeybindUpdateTarget {
1211 keystrokes: &parse_keystrokes("ctrl-b"),
1212 action_name: "zed::SomeOtherAction",
1213 context: None,
1214 use_key_equivalents: false,
1215 action_arguments: None,
1216 },
1217 target_keybind_source: KeybindSource::User,
1218 },
1219 r#"[
1220 {
1221 "bindings": {
1222 "ctrl-a": "zed::SomeAction"
1223 }
1224 },
1225 {
1226 "bindings": {
1227 "ctrl-b": "zed::SomeOtherAction"
1228 }
1229 }
1230 ]"#
1231 .unindent(),
1232 );
1233
1234 check_keymap_update(
1235 r#"[
1236 {
1237 "bindings": {
1238 // some comment
1239 "ctrl-a": "zed::SomeAction"
1240 // some other comment
1241 }
1242 }
1243 ]"#
1244 .unindent(),
1245 KeybindUpdateOperation::Replace {
1246 target: KeybindUpdateTarget {
1247 keystrokes: &parse_keystrokes("ctrl-a"),
1248 action_name: "zed::SomeAction",
1249 context: None,
1250 use_key_equivalents: false,
1251 action_arguments: None,
1252 },
1253 source: KeybindUpdateTarget {
1254 keystrokes: &parse_keystrokes("ctrl-b"),
1255 action_name: "zed::SomeOtherAction",
1256 context: None,
1257 use_key_equivalents: false,
1258 action_arguments: Some(r#"{"foo": "bar"}"#),
1259 },
1260 target_keybind_source: KeybindSource::User,
1261 },
1262 r#"[
1263 {
1264 "bindings": {
1265 // some comment
1266 "ctrl-b": [
1267 "zed::SomeOtherAction",
1268 {
1269 "foo": "bar"
1270 }
1271 ]
1272 // some other comment
1273 }
1274 }
1275 ]"#
1276 .unindent(),
1277 );
1278
1279 check_keymap_update(
1280 r#"[
1281 {
1282 "context": "SomeContext",
1283 "bindings": {
1284 "a": "foo::bar",
1285 "b": "baz::qux",
1286 }
1287 }
1288 ]"#
1289 .unindent(),
1290 KeybindUpdateOperation::Replace {
1291 target: KeybindUpdateTarget {
1292 keystrokes: &parse_keystrokes("a"),
1293 action_name: "foo::bar",
1294 context: Some("SomeContext"),
1295 use_key_equivalents: false,
1296 action_arguments: None,
1297 },
1298 source: KeybindUpdateTarget {
1299 keystrokes: &parse_keystrokes("c"),
1300 action_name: "foo::baz",
1301 context: Some("SomeOtherContext"),
1302 use_key_equivalents: false,
1303 action_arguments: None,
1304 },
1305 target_keybind_source: KeybindSource::User,
1306 },
1307 r#"[
1308 {
1309 "context": "SomeContext",
1310 "bindings": {
1311 "b": "baz::qux",
1312 }
1313 },
1314 {
1315 "context": "SomeOtherContext",
1316 "bindings": {
1317 "c": "foo::baz"
1318 }
1319 }
1320 ]"#
1321 .unindent(),
1322 );
1323
1324 check_keymap_update(
1325 r#"[
1326 {
1327 "context": "SomeContext",
1328 "bindings": {
1329 "a": "foo::bar",
1330 }
1331 }
1332 ]"#
1333 .unindent(),
1334 KeybindUpdateOperation::Replace {
1335 target: KeybindUpdateTarget {
1336 keystrokes: &parse_keystrokes("a"),
1337 action_name: "foo::bar",
1338 context: Some("SomeContext"),
1339 use_key_equivalents: false,
1340 action_arguments: None,
1341 },
1342 source: KeybindUpdateTarget {
1343 keystrokes: &parse_keystrokes("c"),
1344 action_name: "foo::baz",
1345 context: Some("SomeOtherContext"),
1346 use_key_equivalents: false,
1347 action_arguments: None,
1348 },
1349 target_keybind_source: KeybindSource::User,
1350 },
1351 r#"[
1352 {
1353 "context": "SomeOtherContext",
1354 "bindings": {
1355 "c": "foo::baz",
1356 }
1357 }
1358 ]"#
1359 .unindent(),
1360 );
1361
1362 check_keymap_update(
1363 r#"[
1364 {
1365 "context": "SomeContext",
1366 "bindings": {
1367 "a": "foo::bar",
1368 "c": "foo::baz",
1369 }
1370 },
1371 ]"#
1372 .unindent(),
1373 KeybindUpdateOperation::Remove {
1374 target: KeybindUpdateTarget {
1375 context: Some("SomeContext"),
1376 keystrokes: &parse_keystrokes("a"),
1377 action_name: "foo::bar",
1378 use_key_equivalents: false,
1379 action_arguments: None,
1380 },
1381 target_keybind_source: KeybindSource::User,
1382 },
1383 r#"[
1384 {
1385 "context": "SomeContext",
1386 "bindings": {
1387 "c": "foo::baz",
1388 }
1389 },
1390 ]"#
1391 .unindent(),
1392 );
1393
1394 check_keymap_update(
1395 r#"[
1396 {
1397 "context": "SomeContext",
1398 "bindings": {
1399 "a": ["foo::bar", true],
1400 "c": "foo::baz",
1401 }
1402 },
1403 ]"#
1404 .unindent(),
1405 KeybindUpdateOperation::Remove {
1406 target: KeybindUpdateTarget {
1407 context: Some("SomeContext"),
1408 keystrokes: &parse_keystrokes("a"),
1409 action_name: "foo::bar",
1410 use_key_equivalents: false,
1411 action_arguments: Some("true"),
1412 },
1413 target_keybind_source: KeybindSource::User,
1414 },
1415 r#"[
1416 {
1417 "context": "SomeContext",
1418 "bindings": {
1419 "c": "foo::baz",
1420 }
1421 },
1422 ]"#
1423 .unindent(),
1424 );
1425
1426 check_keymap_update(
1427 r#"[
1428 {
1429 "context": "SomeContext",
1430 "bindings": {
1431 "b": "foo::baz",
1432 }
1433 },
1434 {
1435 "context": "SomeContext",
1436 "bindings": {
1437 "a": ["foo::bar", true],
1438 }
1439 },
1440 {
1441 "context": "SomeContext",
1442 "bindings": {
1443 "c": "foo::baz",
1444 }
1445 },
1446 ]"#
1447 .unindent(),
1448 KeybindUpdateOperation::Remove {
1449 target: KeybindUpdateTarget {
1450 context: Some("SomeContext"),
1451 keystrokes: &parse_keystrokes("a"),
1452 action_name: "foo::bar",
1453 use_key_equivalents: false,
1454 action_arguments: Some("true"),
1455 },
1456 target_keybind_source: KeybindSource::User,
1457 },
1458 r#"[
1459 {
1460 "context": "SomeContext",
1461 "bindings": {
1462 "b": "foo::baz",
1463 }
1464 },
1465 {
1466 "context": "SomeContext",
1467 "bindings": {
1468 "c": "foo::baz",
1469 }
1470 },
1471 ]"#
1472 .unindent(),
1473 );
1474 }
1475}