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 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 pub fn generate_json_schema_for_registered_actions(cx: &mut App) -> Value {
430 // instead of using DefaultDenyUnknownFields, actions typically use
431 // `#[serde(deny_unknown_fields)]` so that these cases are reported as parse failures. This
432 // is because the rest of the keymap will still load in these cases, whereas other settings
433 // files would not.
434 let mut generator = schemars::generate::SchemaSettings::draft2019_09().into_generator();
435
436 let action_schemas = cx.action_schemas(&mut generator);
437 let deprecations = cx.deprecated_actions_to_preferred_actions();
438 let deprecation_messages = cx.action_deprecation_messages();
439 KeymapFile::generate_json_schema(
440 generator,
441 action_schemas,
442 deprecations,
443 deprecation_messages,
444 )
445 }
446
447 fn generate_json_schema(
448 mut generator: schemars::SchemaGenerator,
449 action_schemas: Vec<(&'static str, Option<schemars::Schema>)>,
450 deprecations: &HashMap<&'static str, &'static str>,
451 deprecation_messages: &HashMap<&'static str, &'static str>,
452 ) -> serde_json::Value {
453 fn add_deprecation(schema: &mut schemars::Schema, message: String) {
454 schema.insert(
455 // deprecationMessage is not part of the JSON Schema spec, but
456 // json-language-server recognizes it.
457 "deprecationMessage".to_string(),
458 Value::String(message),
459 );
460 }
461
462 fn add_deprecation_preferred_name(schema: &mut schemars::Schema, new_name: &str) {
463 add_deprecation(schema, format!("Deprecated, use {new_name}"));
464 }
465
466 fn add_description(schema: &mut schemars::Schema, description: String) {
467 schema.insert("description".to_string(), Value::String(description));
468 }
469
470 let empty_object = json_schema!({
471 "type": "object"
472 });
473
474 // This is a workaround for a json-language-server issue where it matches the first
475 // alternative that matches the value's shape and uses that for documentation.
476 //
477 // In the case of the array validations, it would even provide an error saying that the name
478 // must match the name of the first alternative.
479 let mut plain_action = json_schema!({
480 "type": "string",
481 "const": ""
482 });
483 let no_action_message = "No action named this.";
484 add_description(&mut plain_action, no_action_message.to_owned());
485 add_deprecation(&mut plain_action, no_action_message.to_owned());
486
487 let mut matches_action_name = json_schema!({
488 "const": ""
489 });
490 let no_action_message_input = "No action named this that takes input.";
491 add_description(&mut matches_action_name, no_action_message_input.to_owned());
492 add_deprecation(&mut matches_action_name, no_action_message_input.to_owned());
493
494 let action_with_input = json_schema!({
495 "type": "array",
496 "items": [
497 matches_action_name,
498 true
499 ],
500 "minItems": 2,
501 "maxItems": 2
502 });
503 let mut keymap_action_alternatives = vec![plain_action, action_with_input];
504
505 for (name, action_schema) in action_schemas.into_iter() {
506 let description = action_schema.as_ref().and_then(|schema| {
507 schema
508 .as_object()
509 .and_then(|obj| obj.get("description"))
510 .and_then(|v| v.as_str())
511 .map(|s| s.to_string())
512 });
513
514 let deprecation = if name == NoAction.name() {
515 Some("null")
516 } else {
517 deprecations.get(name).copied()
518 };
519
520 // Add an alternative for plain action names.
521 let mut plain_action = json_schema!({
522 "type": "string",
523 "const": name
524 });
525 if let Some(message) = deprecation_messages.get(name) {
526 add_deprecation(&mut plain_action, message.to_string());
527 } else if let Some(new_name) = deprecation {
528 add_deprecation_preferred_name(&mut plain_action, new_name);
529 }
530 if let Some(desc) = description.clone() {
531 add_description(&mut plain_action, desc);
532 }
533 keymap_action_alternatives.push(plain_action);
534
535 // Add an alternative for actions with data specified as a [name, data] array.
536 //
537 // When a struct with no deserializable fields is added by deriving `Action`, an empty
538 // object schema is produced. The action should be invoked without data in this case.
539 if let Some(schema) = action_schema {
540 if schema != empty_object {
541 let mut matches_action_name = json_schema!({
542 "const": name
543 });
544 if let Some(desc) = description.clone() {
545 add_description(&mut matches_action_name, desc);
546 }
547 if let Some(message) = deprecation_messages.get(name) {
548 add_deprecation(&mut matches_action_name, message.to_string());
549 } else if let Some(new_name) = deprecation {
550 add_deprecation_preferred_name(&mut matches_action_name, new_name);
551 }
552 let action_with_input = json_schema!({
553 "type": "array",
554 "items": [matches_action_name, schema],
555 "minItems": 2,
556 "maxItems": 2
557 });
558 keymap_action_alternatives.push(action_with_input);
559 }
560 }
561 }
562
563 // Placing null first causes json-language-server to default assuming actions should be
564 // null, so place it last.
565 keymap_action_alternatives.push(json_schema!({
566 "type": "null"
567 }));
568
569 // The `KeymapSection` schema will reference the `KeymapAction` schema by name, so setting
570 // the definition of `KeymapAction` results in the full action schema being used.
571 generator.definitions_mut().insert(
572 KeymapAction::schema_name().to_string(),
573 json!({
574 "oneOf": keymap_action_alternatives
575 }),
576 );
577
578 generator.root_schema_for::<KeymapFile>().to_value()
579 }
580
581 pub fn sections(&self) -> impl DoubleEndedIterator<Item = &KeymapSection> {
582 self.0.iter()
583 }
584
585 pub async fn load_keymap_file(fs: &Arc<dyn Fs>) -> Result<String> {
586 match fs.load(paths::keymap_file()).await {
587 result @ Ok(_) => result,
588 Err(err) => {
589 if let Some(e) = err.downcast_ref::<std::io::Error>() {
590 if e.kind() == std::io::ErrorKind::NotFound {
591 return Ok(crate::initial_keymap_content().to_string());
592 }
593 }
594 Err(err)
595 }
596 }
597 }
598
599 pub fn update_keybinding<'a>(
600 mut operation: KeybindUpdateOperation<'a>,
601 mut keymap_contents: String,
602 tab_size: usize,
603 ) -> Result<String> {
604 // if trying to replace a keybinding that is not user-defined, treat it as an add operation
605 match operation {
606 KeybindUpdateOperation::Replace {
607 target_keybind_source: target_source,
608 source,
609 ..
610 } if target_source != KeybindSource::User => {
611 operation = KeybindUpdateOperation::Add(source);
612 }
613 _ => {}
614 }
615
616 // Sanity check that keymap contents are valid, even though we only use it for Replace.
617 // We don't want to modify the file if it's invalid.
618 let keymap = Self::parse(&keymap_contents).context("Failed to parse keymap")?;
619
620 if let KeybindUpdateOperation::Replace { source, target, .. } = operation {
621 let mut found_index = None;
622 let target_action_value = target
623 .action_value()
624 .context("Failed to generate target action JSON value")?;
625 let source_action_value = source
626 .action_value()
627 .context("Failed to generate source action JSON value")?;
628 'sections: for (index, section) in keymap.sections().enumerate() {
629 if section.context != target.context.unwrap_or("") {
630 continue;
631 }
632 if section.use_key_equivalents != target.use_key_equivalents {
633 continue;
634 }
635 let Some(bindings) = §ion.bindings else {
636 continue;
637 };
638 for (keystrokes, action) in bindings {
639 let Ok(keystrokes) = keystrokes
640 .split_whitespace()
641 .map(Keystroke::parse)
642 .collect::<Result<Vec<_>, _>>()
643 else {
644 continue;
645 };
646 if keystrokes.len() != target.keystrokes.len()
647 || !keystrokes
648 .iter()
649 .zip(target.keystrokes)
650 .all(|(a, b)| a.should_match(b))
651 {
652 continue;
653 }
654 if action.0 != target_action_value {
655 continue;
656 }
657 found_index = Some(index);
658 break 'sections;
659 }
660 }
661
662 if let Some(index) = found_index {
663 if target.context == source.context {
664 // if we are only changing the keybinding (common case)
665 // not the context, etc. Then just update the binding in place
666
667 let (replace_range, replace_value) =
668 replace_top_level_array_value_in_json_text(
669 &keymap_contents,
670 &["bindings", &target.keystrokes_unparsed()],
671 Some(&source_action_value),
672 Some(&source.keystrokes_unparsed()),
673 index,
674 tab_size,
675 )
676 .context("Failed to replace keybinding")?;
677 keymap_contents.replace_range(replace_range, &replace_value);
678
679 return Ok(keymap_contents);
680 } else if keymap.0[index]
681 .bindings
682 .as_ref()
683 .map_or(true, |bindings| bindings.len() == 1)
684 {
685 // if we are replacing the only binding in the section,
686 // just update the section in place, updating the context
687 // and the binding
688
689 let (replace_range, replace_value) =
690 replace_top_level_array_value_in_json_text(
691 &keymap_contents,
692 &["bindings", &target.keystrokes_unparsed()],
693 Some(&source_action_value),
694 Some(&source.keystrokes_unparsed()),
695 index,
696 tab_size,
697 )
698 .context("Failed to replace keybinding")?;
699 keymap_contents.replace_range(replace_range, &replace_value);
700
701 let (replace_range, replace_value) =
702 replace_top_level_array_value_in_json_text(
703 &keymap_contents,
704 &["context"],
705 source.context.map(Into::into).as_ref(),
706 None,
707 index,
708 tab_size,
709 )
710 .context("Failed to replace keybinding")?;
711 keymap_contents.replace_range(replace_range, &replace_value);
712 return Ok(keymap_contents);
713 } else {
714 // if we are replacing one of multiple bindings in a section
715 // with a context change, remove the existing binding from the
716 // section, then treat this operation as an add operation of the
717 // new binding with the updated context.
718
719 let (replace_range, replace_value) =
720 replace_top_level_array_value_in_json_text(
721 &keymap_contents,
722 &["bindings", &target.keystrokes_unparsed()],
723 None,
724 None,
725 index,
726 tab_size,
727 )
728 .context("Failed to replace keybinding")?;
729 keymap_contents.replace_range(replace_range, &replace_value);
730 operation = KeybindUpdateOperation::Add(source);
731 }
732 } else {
733 log::warn!(
734 "Failed to find keybinding to update `{:?} -> {}` creating new binding for `{:?} -> {}` instead",
735 target.keystrokes,
736 target_action_value,
737 source.keystrokes,
738 source_action_value,
739 );
740 operation = KeybindUpdateOperation::Add(source);
741 }
742 }
743
744 if let KeybindUpdateOperation::Add(keybinding) = operation {
745 let mut value = serde_json::Map::with_capacity(4);
746 if let Some(context) = keybinding.context {
747 value.insert("context".to_string(), context.into());
748 }
749 if keybinding.use_key_equivalents {
750 value.insert("use_key_equivalents".to_string(), true.into());
751 }
752
753 value.insert("bindings".to_string(), {
754 let mut bindings = serde_json::Map::new();
755 let action = keybinding.action_value()?;
756 bindings.insert(keybinding.keystrokes_unparsed(), action);
757 bindings.into()
758 });
759
760 let (replace_range, replace_value) = append_top_level_array_value_in_json_text(
761 &keymap_contents,
762 &value.into(),
763 tab_size,
764 )?;
765 keymap_contents.replace_range(replace_range, &replace_value);
766 }
767 return Ok(keymap_contents);
768 }
769}
770
771pub enum KeybindUpdateOperation<'a> {
772 Replace {
773 /// Describes the keybind to create
774 source: KeybindUpdateTarget<'a>,
775 /// Describes the keybind to remove
776 target: KeybindUpdateTarget<'a>,
777 target_keybind_source: KeybindSource,
778 },
779 Add(KeybindUpdateTarget<'a>),
780}
781
782pub struct KeybindUpdateTarget<'a> {
783 pub context: Option<&'a str>,
784 pub keystrokes: &'a [Keystroke],
785 pub action_name: &'a str,
786 pub use_key_equivalents: bool,
787 pub input: Option<&'a str>,
788}
789
790impl<'a> KeybindUpdateTarget<'a> {
791 fn action_value(&self) -> Result<Value> {
792 let action_name: Value = self.action_name.into();
793 let value = match self.input {
794 Some(input) => {
795 let input = serde_json::from_str::<Value>(input)
796 .context("Failed to parse action input as JSON")?;
797 serde_json::json!([action_name, input])
798 }
799 None => action_name,
800 };
801 return Ok(value);
802 }
803
804 fn keystrokes_unparsed(&self) -> String {
805 let mut keystrokes = String::with_capacity(self.keystrokes.len() * 8);
806 for keystroke in self.keystrokes {
807 keystrokes.push_str(&keystroke.unparse());
808 keystrokes.push(' ');
809 }
810 keystrokes.pop();
811 keystrokes
812 }
813}
814
815#[derive(Clone, Copy, PartialEq, Eq)]
816pub enum KeybindSource {
817 User,
818 Default,
819 Base,
820 Vim,
821}
822
823impl KeybindSource {
824 const BASE: KeyBindingMetaIndex = KeyBindingMetaIndex(0);
825 const DEFAULT: KeyBindingMetaIndex = KeyBindingMetaIndex(1);
826 const VIM: KeyBindingMetaIndex = KeyBindingMetaIndex(2);
827 const USER: KeyBindingMetaIndex = KeyBindingMetaIndex(3);
828
829 pub fn name(&self) -> &'static str {
830 match self {
831 KeybindSource::User => "User",
832 KeybindSource::Default => "Default",
833 KeybindSource::Base => "Base",
834 KeybindSource::Vim => "Vim",
835 }
836 }
837
838 pub fn meta(&self) -> KeyBindingMetaIndex {
839 match self {
840 KeybindSource::User => Self::USER,
841 KeybindSource::Default => Self::DEFAULT,
842 KeybindSource::Base => Self::BASE,
843 KeybindSource::Vim => Self::VIM,
844 }
845 }
846
847 pub fn from_meta(index: KeyBindingMetaIndex) -> Self {
848 match index {
849 Self::USER => KeybindSource::User,
850 Self::BASE => KeybindSource::Base,
851 Self::DEFAULT => KeybindSource::Default,
852 Self::VIM => KeybindSource::Vim,
853 _ => unreachable!(),
854 }
855 }
856}
857
858impl From<KeyBindingMetaIndex> for KeybindSource {
859 fn from(index: KeyBindingMetaIndex) -> Self {
860 Self::from_meta(index)
861 }
862}
863
864impl From<KeybindSource> for KeyBindingMetaIndex {
865 fn from(source: KeybindSource) -> Self {
866 return source.meta();
867 }
868}
869
870#[cfg(test)]
871mod tests {
872 use unindent::Unindent;
873
874 use crate::{
875 KeybindSource, KeymapFile,
876 keymap_file::{KeybindUpdateOperation, KeybindUpdateTarget},
877 };
878
879 #[test]
880 fn can_deserialize_keymap_with_trailing_comma() {
881 let json = indoc::indoc! {"[
882 // Standard macOS bindings
883 {
884 \"bindings\": {
885 \"up\": \"menu::SelectPrevious\",
886 },
887 },
888 ]
889 "
890 };
891 KeymapFile::parse(json).unwrap();
892 }
893
894 #[test]
895 fn keymap_update() {
896 use gpui::Keystroke;
897
898 zlog::init_test();
899 #[track_caller]
900 fn check_keymap_update(
901 input: impl ToString,
902 operation: KeybindUpdateOperation,
903 expected: impl ToString,
904 ) {
905 let result = KeymapFile::update_keybinding(operation, input.to_string(), 4)
906 .expect("Update succeeded");
907 pretty_assertions::assert_eq!(expected.to_string(), result);
908 }
909
910 #[track_caller]
911 fn parse_keystrokes(keystrokes: &str) -> Vec<Keystroke> {
912 return keystrokes
913 .split(' ')
914 .map(|s| Keystroke::parse(s).expect("Keystrokes valid"))
915 .collect();
916 }
917
918 check_keymap_update(
919 "[]",
920 KeybindUpdateOperation::Add(KeybindUpdateTarget {
921 keystrokes: &parse_keystrokes("ctrl-a"),
922 action_name: "zed::SomeAction",
923 context: None,
924 use_key_equivalents: false,
925 input: None,
926 }),
927 r#"[
928 {
929 "bindings": {
930 "ctrl-a": "zed::SomeAction"
931 }
932 }
933 ]"#
934 .unindent(),
935 );
936
937 check_keymap_update(
938 r#"[
939 {
940 "bindings": {
941 "ctrl-a": "zed::SomeAction"
942 }
943 }
944 ]"#
945 .unindent(),
946 KeybindUpdateOperation::Add(KeybindUpdateTarget {
947 keystrokes: &parse_keystrokes("ctrl-b"),
948 action_name: "zed::SomeOtherAction",
949 context: None,
950 use_key_equivalents: false,
951 input: None,
952 }),
953 r#"[
954 {
955 "bindings": {
956 "ctrl-a": "zed::SomeAction"
957 }
958 },
959 {
960 "bindings": {
961 "ctrl-b": "zed::SomeOtherAction"
962 }
963 }
964 ]"#
965 .unindent(),
966 );
967
968 check_keymap_update(
969 r#"[
970 {
971 "bindings": {
972 "ctrl-a": "zed::SomeAction"
973 }
974 }
975 ]"#
976 .unindent(),
977 KeybindUpdateOperation::Add(KeybindUpdateTarget {
978 keystrokes: &parse_keystrokes("ctrl-b"),
979 action_name: "zed::SomeOtherAction",
980 context: None,
981 use_key_equivalents: false,
982 input: Some(r#"{"foo": "bar"}"#),
983 }),
984 r#"[
985 {
986 "bindings": {
987 "ctrl-a": "zed::SomeAction"
988 }
989 },
990 {
991 "bindings": {
992 "ctrl-b": [
993 "zed::SomeOtherAction",
994 {
995 "foo": "bar"
996 }
997 ]
998 }
999 }
1000 ]"#
1001 .unindent(),
1002 );
1003
1004 check_keymap_update(
1005 r#"[
1006 {
1007 "bindings": {
1008 "ctrl-a": "zed::SomeAction"
1009 }
1010 }
1011 ]"#
1012 .unindent(),
1013 KeybindUpdateOperation::Add(KeybindUpdateTarget {
1014 keystrokes: &parse_keystrokes("ctrl-b"),
1015 action_name: "zed::SomeOtherAction",
1016 context: Some("Zed > Editor && some_condition = true"),
1017 use_key_equivalents: true,
1018 input: Some(r#"{"foo": "bar"}"#),
1019 }),
1020 r#"[
1021 {
1022 "bindings": {
1023 "ctrl-a": "zed::SomeAction"
1024 }
1025 },
1026 {
1027 "context": "Zed > Editor && some_condition = true",
1028 "use_key_equivalents": true,
1029 "bindings": {
1030 "ctrl-b": [
1031 "zed::SomeOtherAction",
1032 {
1033 "foo": "bar"
1034 }
1035 ]
1036 }
1037 }
1038 ]"#
1039 .unindent(),
1040 );
1041
1042 check_keymap_update(
1043 r#"[
1044 {
1045 "bindings": {
1046 "ctrl-a": "zed::SomeAction"
1047 }
1048 }
1049 ]"#
1050 .unindent(),
1051 KeybindUpdateOperation::Replace {
1052 target: KeybindUpdateTarget {
1053 keystrokes: &parse_keystrokes("ctrl-a"),
1054 action_name: "zed::SomeAction",
1055 context: None,
1056 use_key_equivalents: false,
1057 input: None,
1058 },
1059 source: KeybindUpdateTarget {
1060 keystrokes: &parse_keystrokes("ctrl-b"),
1061 action_name: "zed::SomeOtherAction",
1062 context: None,
1063 use_key_equivalents: false,
1064 input: Some(r#"{"foo": "bar"}"#),
1065 },
1066 target_keybind_source: KeybindSource::Base,
1067 },
1068 r#"[
1069 {
1070 "bindings": {
1071 "ctrl-a": "zed::SomeAction"
1072 }
1073 },
1074 {
1075 "bindings": {
1076 "ctrl-b": [
1077 "zed::SomeOtherAction",
1078 {
1079 "foo": "bar"
1080 }
1081 ]
1082 }
1083 }
1084 ]"#
1085 .unindent(),
1086 );
1087
1088 check_keymap_update(
1089 r#"[
1090 {
1091 "bindings": {
1092 "a": "zed::SomeAction"
1093 }
1094 }
1095 ]"#
1096 .unindent(),
1097 KeybindUpdateOperation::Replace {
1098 target: KeybindUpdateTarget {
1099 keystrokes: &parse_keystrokes("a"),
1100 action_name: "zed::SomeAction",
1101 context: None,
1102 use_key_equivalents: false,
1103 input: None,
1104 },
1105 source: KeybindUpdateTarget {
1106 keystrokes: &parse_keystrokes("ctrl-b"),
1107 action_name: "zed::SomeOtherAction",
1108 context: None,
1109 use_key_equivalents: false,
1110 input: Some(r#"{"foo": "bar"}"#),
1111 },
1112 target_keybind_source: KeybindSource::User,
1113 },
1114 r#"[
1115 {
1116 "bindings": {
1117 "ctrl-b": [
1118 "zed::SomeOtherAction",
1119 {
1120 "foo": "bar"
1121 }
1122 ]
1123 }
1124 }
1125 ]"#
1126 .unindent(),
1127 );
1128
1129 check_keymap_update(
1130 r#"[
1131 {
1132 "bindings": {
1133 "ctrl-a": "zed::SomeAction"
1134 }
1135 }
1136 ]"#
1137 .unindent(),
1138 KeybindUpdateOperation::Replace {
1139 target: KeybindUpdateTarget {
1140 keystrokes: &parse_keystrokes("ctrl-a"),
1141 action_name: "zed::SomeNonexistentAction",
1142 context: None,
1143 use_key_equivalents: false,
1144 input: None,
1145 },
1146 source: KeybindUpdateTarget {
1147 keystrokes: &parse_keystrokes("ctrl-b"),
1148 action_name: "zed::SomeOtherAction",
1149 context: None,
1150 use_key_equivalents: false,
1151 input: None,
1152 },
1153 target_keybind_source: KeybindSource::User,
1154 },
1155 r#"[
1156 {
1157 "bindings": {
1158 "ctrl-a": "zed::SomeAction"
1159 }
1160 },
1161 {
1162 "bindings": {
1163 "ctrl-b": "zed::SomeOtherAction"
1164 }
1165 }
1166 ]"#
1167 .unindent(),
1168 );
1169
1170 check_keymap_update(
1171 r#"[
1172 {
1173 "bindings": {
1174 // some comment
1175 "ctrl-a": "zed::SomeAction"
1176 // some other comment
1177 }
1178 }
1179 ]"#
1180 .unindent(),
1181 KeybindUpdateOperation::Replace {
1182 target: KeybindUpdateTarget {
1183 keystrokes: &parse_keystrokes("ctrl-a"),
1184 action_name: "zed::SomeAction",
1185 context: None,
1186 use_key_equivalents: false,
1187 input: None,
1188 },
1189 source: KeybindUpdateTarget {
1190 keystrokes: &parse_keystrokes("ctrl-b"),
1191 action_name: "zed::SomeOtherAction",
1192 context: None,
1193 use_key_equivalents: false,
1194 input: Some(r#"{"foo": "bar"}"#),
1195 },
1196 target_keybind_source: KeybindSource::User,
1197 },
1198 r#"[
1199 {
1200 "bindings": {
1201 // some comment
1202 "ctrl-b": [
1203 "zed::SomeOtherAction",
1204 {
1205 "foo": "bar"
1206 }
1207 ]
1208 // some other comment
1209 }
1210 }
1211 ]"#
1212 .unindent(),
1213 );
1214
1215 check_keymap_update(
1216 r#"[
1217 {
1218 "context": "SomeContext",
1219 "bindings": {
1220 "a": "foo::bar",
1221 "b": "baz::qux",
1222 }
1223 }
1224 ]"#
1225 .unindent(),
1226 KeybindUpdateOperation::Replace {
1227 target: KeybindUpdateTarget {
1228 keystrokes: &parse_keystrokes("a"),
1229 action_name: "foo::bar",
1230 context: Some("SomeContext"),
1231 use_key_equivalents: false,
1232 input: None,
1233 },
1234 source: KeybindUpdateTarget {
1235 keystrokes: &parse_keystrokes("c"),
1236 action_name: "foo::baz",
1237 context: Some("SomeOtherContext"),
1238 use_key_equivalents: false,
1239 input: None,
1240 },
1241 target_keybind_source: KeybindSource::User,
1242 },
1243 r#"[
1244 {
1245 "context": "SomeContext",
1246 "bindings": {
1247 "b": "baz::qux",
1248 }
1249 },
1250 {
1251 "context": "SomeOtherContext",
1252 "bindings": {
1253 "c": "foo::baz"
1254 }
1255 }
1256 ]"#
1257 .unindent(),
1258 );
1259
1260 check_keymap_update(
1261 r#"[
1262 {
1263 "context": "SomeContext",
1264 "bindings": {
1265 "a": "foo::bar",
1266 }
1267 }
1268 ]"#
1269 .unindent(),
1270 KeybindUpdateOperation::Replace {
1271 target: KeybindUpdateTarget {
1272 keystrokes: &parse_keystrokes("a"),
1273 action_name: "foo::bar",
1274 context: Some("SomeContext"),
1275 use_key_equivalents: false,
1276 input: None,
1277 },
1278 source: KeybindUpdateTarget {
1279 keystrokes: &parse_keystrokes("c"),
1280 action_name: "foo::baz",
1281 context: Some("SomeOtherContext"),
1282 use_key_equivalents: false,
1283 input: None,
1284 },
1285 target_keybind_source: KeybindSource::User,
1286 },
1287 r#"[
1288 {
1289 "context": "SomeOtherContext",
1290 "bindings": {
1291 "c": "foo::baz",
1292 }
1293 }
1294 ]"#
1295 .unindent(),
1296 );
1297 }
1298}