1use anyhow::{Context, Result};
2use collections::HashMap;
3use convert_case::{Case, Casing};
4use std::{cmp::Reverse, ops::Range, sync::LazyLock};
5use streaming_iterator::StreamingIterator;
6use tree_sitter::{Query, QueryMatch};
7
8fn migrate(text: &str, patterns: MigrationPatterns, query: &Query) -> Result<Option<String>> {
9 let mut parser = tree_sitter::Parser::new();
10 parser.set_language(&tree_sitter_json::LANGUAGE.into())?;
11 let syntax_tree = parser
12 .parse(&text, None)
13 .context("failed to parse settings")?;
14
15 let mut cursor = tree_sitter::QueryCursor::new();
16 let mut matches = cursor.matches(query, syntax_tree.root_node(), text.as_bytes());
17
18 let mut edits = vec![];
19 while let Some(mat) = matches.next() {
20 if let Some((_, callback)) = patterns.get(mat.pattern_index) {
21 edits.extend(callback(&text, &mat, query));
22 }
23 }
24
25 edits.sort_by_key(|(range, _)| (range.start, Reverse(range.end)));
26 edits.dedup_by(|(range_b, _), (range_a, _)| {
27 range_a.contains(&range_b.start) || range_a.contains(&range_b.end)
28 });
29
30 if edits.is_empty() {
31 Ok(None)
32 } else {
33 let mut new_text = text.to_string();
34 for (range, replacement) in edits.iter().rev() {
35 new_text.replace_range(range.clone(), replacement);
36 }
37 if new_text == text {
38 log::error!(
39 "Edits computed for configuration migration do not cause a change: {:?}",
40 edits
41 );
42 Ok(None)
43 } else {
44 Ok(Some(new_text))
45 }
46 }
47}
48
49pub fn migrate_keymap(text: &str) -> Result<Option<String>> {
50 let transformed_text = migrate(
51 text,
52 KEYMAP_MIGRATION_TRANSFORMATION_PATTERNS,
53 &KEYMAP_MIGRATION_TRANSFORMATION_QUERY,
54 )?;
55 let replacement_text = migrate(
56 &transformed_text.as_ref().unwrap_or(&text.to_string()),
57 KEYMAP_MIGRATION_REPLACEMENT_PATTERNS,
58 &KEYMAP_MIGRATION_REPLACEMENT_QUERY,
59 )?;
60 Ok(replacement_text.or(transformed_text))
61}
62
63pub fn migrate_settings(text: &str) -> Result<Option<String>> {
64 migrate(
65 &text,
66 SETTINGS_MIGRATION_PATTERNS,
67 &SETTINGS_MIGRATION_QUERY,
68 )
69}
70
71pub fn migrate_edit_prediction_provider_settings(text: &str) -> Result<Option<String>> {
72 migrate(
73 &text,
74 &[(
75 SETTINGS_REPLACE_NESTED_KEY,
76 replace_edit_prediction_provider_setting,
77 )],
78 &EDIT_PREDICTION_SETTINGS_MIGRATION_QUERY,
79 )
80}
81
82type MigrationPatterns = &'static [(
83 &'static str,
84 fn(&str, &QueryMatch, &Query) -> Option<(Range<usize>, String)>,
85)];
86
87const KEYMAP_MIGRATION_TRANSFORMATION_PATTERNS: MigrationPatterns = &[
88 (ACTION_ARRAY_PATTERN, replace_array_with_single_string),
89 (
90 ACTION_ARGUMENT_OBJECT_PATTERN,
91 replace_action_argument_object_with_single_value,
92 ),
93 (ACTION_STRING_PATTERN, rename_string_action),
94 (CONTEXT_PREDICATE_PATTERN, rename_context_key),
95];
96
97static KEYMAP_MIGRATION_TRANSFORMATION_QUERY: LazyLock<Query> = LazyLock::new(|| {
98 Query::new(
99 &tree_sitter_json::LANGUAGE.into(),
100 &KEYMAP_MIGRATION_TRANSFORMATION_PATTERNS
101 .iter()
102 .map(|pattern| pattern.0)
103 .collect::<String>(),
104 )
105 .unwrap()
106});
107
108const ACTION_ARRAY_PATTERN: &str = r#"(document
109 (array
110 (object
111 (pair
112 key: (string (string_content) @name)
113 value: (
114 (object
115 (pair
116 key: (string)
117 value: ((array
118 . (string (string_content) @action_name)
119 . (string (string_content) @argument)
120 .)) @array
121 )
122 )
123 )
124 )
125 )
126 )
127 (#eq? @name "bindings")
128)"#;
129
130fn replace_array_with_single_string(
131 contents: &str,
132 mat: &QueryMatch,
133 query: &Query,
134) -> Option<(Range<usize>, String)> {
135 let array_ix = query.capture_index_for_name("array")?;
136 let action_name_ix = query.capture_index_for_name("action_name")?;
137 let argument_ix = query.capture_index_for_name("argument")?;
138
139 let action_name = contents.get(
140 mat.nodes_for_capture_index(action_name_ix)
141 .next()?
142 .byte_range(),
143 )?;
144 let argument = contents.get(
145 mat.nodes_for_capture_index(argument_ix)
146 .next()?
147 .byte_range(),
148 )?;
149
150 let replacement = TRANSFORM_ARRAY.get(&(action_name, argument))?;
151 let replacement_as_string = format!("\"{replacement}\"");
152 let range_to_replace = mat.nodes_for_capture_index(array_ix).next()?.byte_range();
153
154 Some((range_to_replace, replacement_as_string))
155}
156
157static TRANSFORM_ARRAY: LazyLock<HashMap<(&str, &str), &str>> = LazyLock::new(|| {
158 HashMap::from_iter([
159 // activate
160 (
161 ("workspace::ActivatePaneInDirection", "Up"),
162 "workspace::ActivatePaneUp",
163 ),
164 (
165 ("workspace::ActivatePaneInDirection", "Down"),
166 "workspace::ActivatePaneDown",
167 ),
168 (
169 ("workspace::ActivatePaneInDirection", "Left"),
170 "workspace::ActivatePaneLeft",
171 ),
172 (
173 ("workspace::ActivatePaneInDirection", "Right"),
174 "workspace::ActivatePaneRight",
175 ),
176 // swap
177 (
178 ("workspace::SwapPaneInDirection", "Up"),
179 "workspace::SwapPaneUp",
180 ),
181 (
182 ("workspace::SwapPaneInDirection", "Down"),
183 "workspace::SwapPaneDown",
184 ),
185 (
186 ("workspace::SwapPaneInDirection", "Left"),
187 "workspace::SwapPaneLeft",
188 ),
189 (
190 ("workspace::SwapPaneInDirection", "Right"),
191 "workspace::SwapPaneRight",
192 ),
193 // menu
194 (
195 ("app_menu::NavigateApplicationMenuInDirection", "Left"),
196 "app_menu::ActivateMenuLeft",
197 ),
198 (
199 ("app_menu::NavigateApplicationMenuInDirection", "Right"),
200 "app_menu::ActivateMenuRight",
201 ),
202 // vim push
203 (("vim::PushOperator", "Change"), "vim::PushChange"),
204 (("vim::PushOperator", "Delete"), "vim::PushDelete"),
205 (("vim::PushOperator", "Yank"), "vim::PushYank"),
206 (("vim::PushOperator", "Replace"), "vim::PushReplace"),
207 (
208 ("vim::PushOperator", "DeleteSurrounds"),
209 "vim::PushDeleteSurrounds",
210 ),
211 (("vim::PushOperator", "Mark"), "vim::PushMark"),
212 (("vim::PushOperator", "Indent"), "vim::PushIndent"),
213 (("vim::PushOperator", "Outdent"), "vim::PushOutdent"),
214 (("vim::PushOperator", "AutoIndent"), "vim::PushAutoIndent"),
215 (("vim::PushOperator", "Rewrap"), "vim::PushRewrap"),
216 (
217 ("vim::PushOperator", "ShellCommand"),
218 "vim::PushShellCommand",
219 ),
220 (("vim::PushOperator", "Lowercase"), "vim::PushLowercase"),
221 (("vim::PushOperator", "Uppercase"), "vim::PushUppercase"),
222 (
223 ("vim::PushOperator", "OppositeCase"),
224 "vim::PushOppositeCase",
225 ),
226 (("vim::PushOperator", "Register"), "vim::PushRegister"),
227 (
228 ("vim::PushOperator", "RecordRegister"),
229 "vim::PushRecordRegister",
230 ),
231 (
232 ("vim::PushOperator", "ReplayRegister"),
233 "vim::PushReplayRegister",
234 ),
235 (
236 ("vim::PushOperator", "ReplaceWithRegister"),
237 "vim::PushReplaceWithRegister",
238 ),
239 (
240 ("vim::PushOperator", "ToggleComments"),
241 "vim::PushToggleComments",
242 ),
243 // vim switch
244 (("vim::SwitchMode", "Normal"), "vim::SwitchToNormalMode"),
245 (("vim::SwitchMode", "Insert"), "vim::SwitchToInsertMode"),
246 (("vim::SwitchMode", "Replace"), "vim::SwitchToReplaceMode"),
247 (("vim::SwitchMode", "Visual"), "vim::SwitchToVisualMode"),
248 (
249 ("vim::SwitchMode", "VisualLine"),
250 "vim::SwitchToVisualLineMode",
251 ),
252 (
253 ("vim::SwitchMode", "VisualBlock"),
254 "vim::SwitchToVisualBlockMode",
255 ),
256 (
257 ("vim::SwitchMode", "HelixNormal"),
258 "vim::SwitchToHelixNormalMode",
259 ),
260 // vim resize
261 (("vim::ResizePane", "Widen"), "vim::ResizePaneRight"),
262 (("vim::ResizePane", "Narrow"), "vim::ResizePaneLeft"),
263 (("vim::ResizePane", "Shorten"), "vim::ResizePaneDown"),
264 (("vim::ResizePane", "Lengthen"), "vim::ResizePaneUp"),
265 ])
266});
267
268const ACTION_ARGUMENT_OBJECT_PATTERN: &str = r#"(document
269 (array
270 (object
271 (pair
272 key: (string (string_content) @name)
273 value: (
274 (object
275 (pair
276 key: (string)
277 value: ((array
278 . (string (string_content) @action_name)
279 . (object
280 (pair
281 key: (string (string_content) @action_key)
282 value: (_) @argument))
283 . ) @array
284 ))
285 )
286 )
287 )
288 )
289 )
290 (#eq? @name "bindings")
291)"#;
292
293/// [ "editor::FoldAtLevel", { "level": 1 } ] -> [ "editor::FoldAtLevel", 1 ]
294fn replace_action_argument_object_with_single_value(
295 contents: &str,
296 mat: &QueryMatch,
297 query: &Query,
298) -> Option<(Range<usize>, String)> {
299 let array_ix = query.capture_index_for_name("array")?;
300 let action_name_ix = query.capture_index_for_name("action_name")?;
301 let action_key_ix = query.capture_index_for_name("action_key")?;
302 let argument_ix = query.capture_index_for_name("argument")?;
303
304 let action_name = contents.get(
305 mat.nodes_for_capture_index(action_name_ix)
306 .next()?
307 .byte_range(),
308 )?;
309 let action_key = contents.get(
310 mat.nodes_for_capture_index(action_key_ix)
311 .next()?
312 .byte_range(),
313 )?;
314 let argument = contents.get(
315 mat.nodes_for_capture_index(argument_ix)
316 .next()?
317 .byte_range(),
318 )?;
319
320 let new_action_name = UNWRAP_OBJECTS.get(&action_name)?.get(&action_key)?;
321
322 let range_to_replace = mat.nodes_for_capture_index(array_ix).next()?.byte_range();
323 let replacement = format!("[\"{}\", {}]", new_action_name, argument);
324 Some((range_to_replace, replacement))
325}
326
327/// "ctrl-k ctrl-1": [ "editor::PushOperator", { "Object": {} } ] -> [ "editor::vim::PushObject", {} ]
328static UNWRAP_OBJECTS: LazyLock<HashMap<&str, HashMap<&str, &str>>> = LazyLock::new(|| {
329 HashMap::from_iter([
330 (
331 "editor::FoldAtLevel",
332 HashMap::from_iter([("level", "editor::FoldAtLevel")]),
333 ),
334 (
335 "vim::PushOperator",
336 HashMap::from_iter([
337 ("Object", "vim::PushObject"),
338 ("FindForward", "vim::PushFindForward"),
339 ("FindBackward", "vim::PushFindBackward"),
340 ("Sneak", "vim::PushSneak"),
341 ("SneakBackward", "vim::PushSneakBackward"),
342 ("AddSurrounds", "vim::PushAddSurrounds"),
343 ("ChangeSurrounds", "vim::PushChangeSurrounds"),
344 ("Jump", "vim::PushJump"),
345 ("Digraph", "vim::PushDigraph"),
346 ("Literal", "vim::PushLiteral"),
347 ]),
348 ),
349 ])
350});
351
352const KEYMAP_MIGRATION_REPLACEMENT_PATTERNS: MigrationPatterns = &[(
353 ACTION_ARGUMENT_SNAKE_CASE_PATTERN,
354 action_argument_snake_case,
355)];
356
357static KEYMAP_MIGRATION_REPLACEMENT_QUERY: LazyLock<Query> = LazyLock::new(|| {
358 Query::new(
359 &tree_sitter_json::LANGUAGE.into(),
360 &KEYMAP_MIGRATION_REPLACEMENT_PATTERNS
361 .iter()
362 .map(|pattern| pattern.0)
363 .collect::<String>(),
364 )
365 .unwrap()
366});
367
368const ACTION_STRING_PATTERN: &str = r#"(document
369 (array
370 (object
371 (pair
372 key: (string (string_content) @name)
373 value: (
374 (object
375 (pair
376 key: (string)
377 value: (string (string_content) @action_name)
378 )
379 )
380 )
381 )
382 )
383 )
384 (#eq? @name "bindings")
385)"#;
386
387fn rename_string_action(
388 contents: &str,
389 mat: &QueryMatch,
390 query: &Query,
391) -> Option<(Range<usize>, String)> {
392 let action_name_ix = query.capture_index_for_name("action_name")?;
393 let action_name_range = mat
394 .nodes_for_capture_index(action_name_ix)
395 .next()?
396 .byte_range();
397 let action_name = contents.get(action_name_range.clone())?;
398 let new_action_name = STRING_REPLACE.get(&action_name)?;
399 Some((action_name_range, new_action_name.to_string()))
400}
401
402/// "ctrl-k ctrl-1": "inline_completion::ToggleMenu" -> "edit_prediction::ToggleMenu"
403static STRING_REPLACE: LazyLock<HashMap<&str, &str>> = LazyLock::new(|| {
404 HashMap::from_iter([
405 (
406 "inline_completion::ToggleMenu",
407 "edit_prediction::ToggleMenu",
408 ),
409 ("editor::NextInlineCompletion", "editor::NextEditPrediction"),
410 (
411 "editor::PreviousInlineCompletion",
412 "editor::PreviousEditPrediction",
413 ),
414 (
415 "editor::AcceptPartialInlineCompletion",
416 "editor::AcceptPartialEditPrediction",
417 ),
418 ("editor::ShowInlineCompletion", "editor::ShowEditPrediction"),
419 (
420 "editor::AcceptInlineCompletion",
421 "editor::AcceptEditPrediction",
422 ),
423 (
424 "editor::ToggleInlineCompletions",
425 "editor::ToggleEditPrediction",
426 ),
427 ])
428});
429
430const CONTEXT_PREDICATE_PATTERN: &str = r#"
431(array
432 (object
433 (pair
434 key: (string (string_content) @name)
435 value: (string (string_content) @context_predicate)
436 )
437 )
438)
439(#eq? @name "context")
440"#;
441
442fn rename_context_key(
443 contents: &str,
444 mat: &QueryMatch,
445 query: &Query,
446) -> Option<(Range<usize>, String)> {
447 let context_predicate_ix = query.capture_index_for_name("context_predicate")?;
448 let context_predicate_range = mat
449 .nodes_for_capture_index(context_predicate_ix)
450 .next()?
451 .byte_range();
452 let old_predicate = contents.get(context_predicate_range.clone())?.to_string();
453 let mut new_predicate = old_predicate.to_string();
454 for (old_key, new_key) in CONTEXT_REPLACE.iter() {
455 new_predicate = new_predicate.replace(old_key, new_key);
456 }
457 if new_predicate != old_predicate {
458 Some((context_predicate_range, new_predicate.to_string()))
459 } else {
460 None
461 }
462}
463
464const ACTION_ARGUMENT_SNAKE_CASE_PATTERN: &str = r#"(document
465 (array
466 (object
467 (pair
468 key: (string (string_content) @name)
469 value: (
470 (object
471 (pair
472 key: (string)
473 value: ((array
474 . (string (string_content) @action_name)
475 . (object
476 (pair
477 key: (string (string_content) @argument_key)
478 value: (_) @argument_value))
479 . ) @array
480 ))
481 )
482 )
483 )
484 )
485 )
486 (#eq? @name "bindings")
487)"#;
488
489fn is_snake_case(text: &str) -> bool {
490 text == text.to_case(Case::Snake)
491}
492
493fn to_snake_case(text: &str) -> String {
494 text.to_case(Case::Snake)
495}
496
497/// [ "editor::FoldAtLevel", { "SomeKey": "Value" } ] -> [ "editor::FoldAtLevel", { "some_key" : "value" } ]
498fn action_argument_snake_case(
499 contents: &str,
500 mat: &QueryMatch,
501 query: &Query,
502) -> Option<(Range<usize>, String)> {
503 let array_ix = query.capture_index_for_name("array")?;
504 let action_name_ix = query.capture_index_for_name("action_name")?;
505 let argument_key_ix = query.capture_index_for_name("argument_key")?;
506 let argument_value_ix = query.capture_index_for_name("argument_value")?;
507 let action_name = contents.get(
508 mat.nodes_for_capture_index(action_name_ix)
509 .next()?
510 .byte_range(),
511 )?;
512
513 let argument_key = contents.get(
514 mat.nodes_for_capture_index(argument_key_ix)
515 .next()?
516 .byte_range(),
517 )?;
518
519 let argument_value_node = mat.nodes_for_capture_index(argument_value_ix).next()?;
520 let argument_value = contents.get(argument_value_node.byte_range())?;
521
522 let mut needs_replacement = false;
523 let mut new_key = argument_key.to_string();
524 if !is_snake_case(argument_key) {
525 new_key = to_snake_case(argument_key);
526 needs_replacement = true;
527 }
528
529 let mut new_value = argument_value.to_string();
530 if argument_value_node.kind() == "string" {
531 let inner_value = argument_value.trim_matches('"');
532 if !is_snake_case(inner_value) {
533 new_value = format!("\"{}\"", to_snake_case(inner_value));
534 needs_replacement = true;
535 }
536 }
537
538 if !needs_replacement {
539 return None;
540 }
541
542 let range_to_replace = mat.nodes_for_capture_index(array_ix).next()?.byte_range();
543 let replacement = format!(
544 "[\"{}\", {{ \"{}\": {} }}]",
545 action_name, new_key, new_value
546 );
547
548 Some((range_to_replace, replacement))
549}
550
551/// "context": "Editor && inline_completion && !showing_completions" -> "Editor && edit_prediction && !showing_completions"
552pub static CONTEXT_REPLACE: LazyLock<HashMap<&str, &str>> = LazyLock::new(|| {
553 HashMap::from_iter([
554 ("inline_completion", "edit_prediction"),
555 (
556 "inline_completion_requires_modifier",
557 "edit_prediction_requires_modifier",
558 ),
559 ])
560});
561
562const SETTINGS_MIGRATION_PATTERNS: MigrationPatterns = &[
563 (SETTINGS_STRING_REPLACE_QUERY, replace_setting_name),
564 (
565 SETTINGS_REPLACE_NESTED_KEY,
566 replace_edit_prediction_provider_setting,
567 ),
568 (
569 SETTINGS_REPLACE_IN_LANGUAGES_QUERY,
570 replace_setting_in_languages,
571 ),
572];
573
574static SETTINGS_MIGRATION_QUERY: LazyLock<Query> = LazyLock::new(|| {
575 Query::new(
576 &tree_sitter_json::LANGUAGE.into(),
577 &SETTINGS_MIGRATION_PATTERNS
578 .iter()
579 .map(|pattern| pattern.0)
580 .collect::<String>(),
581 )
582 .unwrap()
583});
584
585static EDIT_PREDICTION_SETTINGS_MIGRATION_QUERY: LazyLock<Query> = LazyLock::new(|| {
586 Query::new(
587 &tree_sitter_json::LANGUAGE.into(),
588 SETTINGS_REPLACE_NESTED_KEY,
589 )
590 .unwrap()
591});
592
593const SETTINGS_STRING_REPLACE_QUERY: &str = r#"(document
594 (object
595 (pair
596 key: (string (string_content) @name)
597 value: (_)
598 )
599 )
600)"#;
601
602fn replace_setting_name(
603 contents: &str,
604 mat: &QueryMatch,
605 query: &Query,
606) -> Option<(Range<usize>, String)> {
607 let setting_capture_ix = query.capture_index_for_name("name")?;
608 let setting_name_range = mat
609 .nodes_for_capture_index(setting_capture_ix)
610 .next()?
611 .byte_range();
612 let setting_name = contents.get(setting_name_range.clone())?;
613 let new_setting_name = SETTINGS_STRING_REPLACE.get(&setting_name)?;
614 Some((setting_name_range, new_setting_name.to_string()))
615}
616
617pub static SETTINGS_STRING_REPLACE: LazyLock<HashMap<&'static str, &'static str>> =
618 LazyLock::new(|| {
619 HashMap::from_iter([
620 (
621 "show_inline_completions_in_menu",
622 "show_edit_predictions_in_menu",
623 ),
624 ("show_inline_completions", "show_edit_predictions"),
625 (
626 "inline_completions_disabled_in",
627 "edit_predictions_disabled_in",
628 ),
629 ("inline_completions", "edit_predictions"),
630 ])
631 });
632
633const SETTINGS_REPLACE_NESTED_KEY: &str = r#"
634(object
635 (pair
636 key: (string (string_content) @parent_key)
637 value: (object
638 (pair
639 key: (string (string_content) @setting_name)
640 value: (_) @value
641 )
642 )
643 )
644)
645"#;
646
647fn replace_edit_prediction_provider_setting(
648 contents: &str,
649 mat: &QueryMatch,
650 query: &Query,
651) -> Option<(Range<usize>, String)> {
652 let parent_object_capture_ix = query.capture_index_for_name("parent_key")?;
653 let parent_object_range = mat
654 .nodes_for_capture_index(parent_object_capture_ix)
655 .next()?
656 .byte_range();
657 let parent_object_name = contents.get(parent_object_range.clone())?;
658
659 let setting_name_ix = query.capture_index_for_name("setting_name")?;
660 let setting_range = mat
661 .nodes_for_capture_index(setting_name_ix)
662 .next()?
663 .byte_range();
664 let setting_name = contents.get(setting_range.clone())?;
665
666 if parent_object_name == "features" && setting_name == "inline_completion_provider" {
667 return Some((setting_range, "edit_prediction_provider".into()));
668 }
669
670 None
671}
672
673const SETTINGS_REPLACE_IN_LANGUAGES_QUERY: &str = r#"
674(object
675 (pair
676 key: (string (string_content) @languages)
677 value: (object
678 (pair
679 key: (string)
680 value: (object
681 (pair
682 key: (string (string_content) @setting_name)
683 value: (_) @value
684 )
685 )
686 ))
687 )
688)
689(#eq? @languages "languages")
690"#;
691
692fn replace_setting_in_languages(
693 contents: &str,
694 mat: &QueryMatch,
695 query: &Query,
696) -> Option<(Range<usize>, String)> {
697 let setting_capture_ix = query.capture_index_for_name("setting_name")?;
698 let setting_name_range = mat
699 .nodes_for_capture_index(setting_capture_ix)
700 .next()?
701 .byte_range();
702 let setting_name = contents.get(setting_name_range.clone())?;
703 let new_setting_name = LANGUAGE_SETTINGS_REPLACE.get(&setting_name)?;
704
705 Some((setting_name_range, new_setting_name.to_string()))
706}
707
708static LANGUAGE_SETTINGS_REPLACE: LazyLock<HashMap<&'static str, &'static str>> =
709 LazyLock::new(|| {
710 HashMap::from_iter([
711 ("show_inline_completions", "show_edit_predictions"),
712 (
713 "inline_completions_disabled_in",
714 "edit_predictions_disabled_in",
715 ),
716 ])
717 });
718
719#[cfg(test)]
720mod tests {
721 use super::*;
722
723 fn assert_migrate_keymap(input: &str, output: Option<&str>) {
724 let migrated = migrate_keymap(&input).unwrap();
725 pretty_assertions::assert_eq!(migrated.as_deref(), output);
726 }
727
728 fn assert_migrate_settings(input: &str, output: Option<&str>) {
729 let migrated = migrate_settings(&input).unwrap();
730 pretty_assertions::assert_eq!(migrated.as_deref(), output);
731 }
732
733 #[test]
734 fn test_replace_array_with_single_string() {
735 assert_migrate_keymap(
736 r#"
737 [
738 {
739 "bindings": {
740 "cmd-1": ["workspace::ActivatePaneInDirection", "Up"]
741 }
742 }
743 ]
744 "#,
745 Some(
746 r#"
747 [
748 {
749 "bindings": {
750 "cmd-1": "workspace::ActivatePaneUp"
751 }
752 }
753 ]
754 "#,
755 ),
756 )
757 }
758
759 #[test]
760 fn test_replace_action_argument_object_with_single_value() {
761 assert_migrate_keymap(
762 r#"
763 [
764 {
765 "bindings": {
766 "cmd-1": ["editor::FoldAtLevel", { "level": 1 }]
767 }
768 }
769 ]
770 "#,
771 Some(
772 r#"
773 [
774 {
775 "bindings": {
776 "cmd-1": ["editor::FoldAtLevel", 1]
777 }
778 }
779 ]
780 "#,
781 ),
782 )
783 }
784
785 #[test]
786 fn test_replace_action_argument_object_with_single_value_2() {
787 assert_migrate_keymap(
788 r#"
789 [
790 {
791 "bindings": {
792 "cmd-1": ["vim::PushOperator", { "Object": { "some" : "value" } }]
793 }
794 }
795 ]
796 "#,
797 Some(
798 r#"
799 [
800 {
801 "bindings": {
802 "cmd-1": ["vim::PushObject", { "some" : "value" }]
803 }
804 }
805 ]
806 "#,
807 ),
808 )
809 }
810
811 #[test]
812 fn test_rename_string_action() {
813 assert_migrate_keymap(
814 r#"
815 [
816 {
817 "bindings": {
818 "cmd-1": "inline_completion::ToggleMenu"
819 }
820 }
821 ]
822 "#,
823 Some(
824 r#"
825 [
826 {
827 "bindings": {
828 "cmd-1": "edit_prediction::ToggleMenu"
829 }
830 }
831 ]
832 "#,
833 ),
834 )
835 }
836
837 #[test]
838 fn test_rename_context_key() {
839 assert_migrate_keymap(
840 r#"
841 [
842 {
843 "context": "Editor && inline_completion && !showing_completions"
844 }
845 ]
846 "#,
847 Some(
848 r#"
849 [
850 {
851 "context": "Editor && edit_prediction && !showing_completions"
852 }
853 ]
854 "#,
855 ),
856 )
857 }
858
859 #[test]
860 fn test_action_argument_snake_case() {
861 // First performs transformations, then replacements
862 assert_migrate_keymap(
863 r#"
864 [
865 {
866 "bindings": {
867 "cmd-1": ["vim::PushOperator", { "Object": { "SomeKey": "Value" } }],
868 "cmd-2": ["vim::SomeOtherAction", { "OtherKey": "Value" }],
869 "cmd-3": ["vim::SomeDifferentAction", { "OtherKey": true }],
870 "cmd-4": ["vim::OneMore", { "OtherKey": 4 }]
871 }
872 }
873 ]
874 "#,
875 Some(
876 r#"
877 [
878 {
879 "bindings": {
880 "cmd-1": ["vim::PushObject", { "some_key": "value" }],
881 "cmd-2": ["vim::SomeOtherAction", { "other_key": "value" }],
882 "cmd-3": ["vim::SomeDifferentAction", { "other_key": true }],
883 "cmd-4": ["vim::OneMore", { "other_key": 4 }]
884 }
885 }
886 ]
887 "#,
888 ),
889 )
890 }
891
892 #[test]
893 fn test_replace_setting_name() {
894 assert_migrate_settings(
895 r#"
896 {
897 "show_inline_completions_in_menu": true,
898 "show_inline_completions": true,
899 "inline_completions_disabled_in": ["string"],
900 "inline_completions": { "some" : "value" }
901 }
902 "#,
903 Some(
904 r#"
905 {
906 "show_edit_predictions_in_menu": true,
907 "show_edit_predictions": true,
908 "edit_predictions_disabled_in": ["string"],
909 "edit_predictions": { "some" : "value" }
910 }
911 "#,
912 ),
913 )
914 }
915
916 #[test]
917 fn test_nested_string_replace_for_settings() {
918 assert_migrate_settings(
919 r#"
920 {
921 "features": {
922 "inline_completion_provider": "zed"
923 },
924 }
925 "#,
926 Some(
927 r#"
928 {
929 "features": {
930 "edit_prediction_provider": "zed"
931 },
932 }
933 "#,
934 ),
935 )
936 }
937
938 #[test]
939 fn test_replace_settings_in_languages() {
940 assert_migrate_settings(
941 r#"
942 {
943 "languages": {
944 "Astro": {
945 "show_inline_completions": true
946 }
947 }
948 }
949 "#,
950 Some(
951 r#"
952 {
953 "languages": {
954 "Astro": {
955 "show_edit_predictions": true
956 }
957 }
958 }
959 "#,
960 ),
961 )
962 }
963}