1use crate::*;
2use anyhow::{Context as _, Result, anyhow};
3use collections::HashMap;
4use fs::Fs;
5use gpui::Rgba;
6use paths::{cursor_settings_file_paths, vscode_settings_file_paths};
7use serde::Deserialize;
8use serde_json::{Map, Value};
9use std::{
10 num::{NonZeroU32, NonZeroUsize},
11 path::{Path, PathBuf},
12 sync::Arc,
13};
14
15#[derive(Clone, Copy, PartialEq, Eq, Debug)]
16pub enum VsCodeSettingsSource {
17 VsCode,
18 Cursor,
19}
20
21impl std::fmt::Display for VsCodeSettingsSource {
22 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23 match self {
24 VsCodeSettingsSource::VsCode => write!(f, "VS Code"),
25 VsCodeSettingsSource::Cursor => write!(f, "Cursor"),
26 }
27 }
28}
29
30pub struct VsCodeSettings {
31 pub source: VsCodeSettingsSource,
32 pub path: Arc<Path>,
33 content: Map<String, Value>,
34}
35
36impl VsCodeSettings {
37 #[cfg(any(test, feature = "test-support"))]
38 pub fn from_str(content: &str, source: VsCodeSettingsSource) -> Result<Self> {
39 Ok(Self {
40 source,
41 path: Path::new("/example-path/Code/User/settings.json").into(),
42 content: serde_json_lenient::from_str(content)?,
43 })
44 }
45
46 pub async fn load_user_settings(source: VsCodeSettingsSource, fs: Arc<dyn Fs>) -> Result<Self> {
47 let candidate_paths = match source {
48 VsCodeSettingsSource::VsCode => vscode_settings_file_paths(),
49 VsCodeSettingsSource::Cursor => cursor_settings_file_paths(),
50 };
51 let mut path = None;
52 for candidate_path in candidate_paths.iter() {
53 if fs.is_file(candidate_path).await {
54 path = Some(candidate_path.clone());
55 }
56 }
57 let Some(path) = path else {
58 return Err(anyhow!(
59 "No settings file found, expected to find it in one of the following paths:\n{}",
60 candidate_paths
61 .into_iter()
62 .map(|path| path.to_string_lossy().into_owned())
63 .collect::<Vec<_>>()
64 .join("\n")
65 ));
66 };
67 let content = fs.load(&path).await.with_context(|| {
68 format!(
69 "Error loading {} settings file from {}",
70 source,
71 path.display()
72 )
73 })?;
74 let content = serde_json_lenient::from_str(&content).with_context(|| {
75 format!(
76 "Error parsing {} settings file from {}",
77 source,
78 path.display()
79 )
80 })?;
81 Ok(Self {
82 source,
83 path: path.into(),
84 content,
85 })
86 }
87
88 fn read_value(&self, setting: &str) -> Option<&Value> {
89 self.content.get(setting)
90 }
91
92 fn read_str(&self, setting: &str) -> Option<&str> {
93 self.read_value(setting).and_then(|v| v.as_str())
94 }
95
96 fn read_string(&self, setting: &str) -> Option<String> {
97 self.read_value(setting)
98 .and_then(|v| v.as_str())
99 .map(|s| s.to_owned())
100 }
101
102 fn read_bool(&self, setting: &str) -> Option<bool> {
103 self.read_value(setting).and_then(|v| v.as_bool())
104 }
105
106 fn read_f32(&self, setting: &str) -> Option<f32> {
107 self.read_value(setting)
108 .and_then(|v| v.as_f64())
109 .map(|v| v as f32)
110 }
111
112 fn read_u64(&self, setting: &str) -> Option<u64> {
113 self.read_value(setting).and_then(|v| v.as_u64())
114 }
115
116 fn read_usize(&self, setting: &str) -> Option<usize> {
117 self.read_value(setting)
118 .and_then(|v| v.as_u64())
119 .and_then(|v| v.try_into().ok())
120 }
121
122 fn read_u32(&self, setting: &str) -> Option<u32> {
123 self.read_value(setting)
124 .and_then(|v| v.as_u64())
125 .and_then(|v| v.try_into().ok())
126 }
127
128 fn read_enum<T>(&self, key: &str, f: impl FnOnce(&str) -> Option<T>) -> Option<T> {
129 self.content.get(key).and_then(Value::as_str).and_then(f)
130 }
131
132 fn read_fonts(&self, key: &str) -> (Option<FontFamilyName>, Option<Vec<FontFamilyName>>) {
133 let Some(css_name) = self.content.get(key).and_then(Value::as_str) else {
134 return (None, None);
135 };
136
137 let mut name_buffer = String::new();
138 let mut quote_char: Option<char> = None;
139 let mut fonts = Vec::new();
140 let mut add_font = |buffer: &mut String| {
141 let trimmed = buffer.trim();
142 if !trimmed.is_empty() {
143 fonts.push(trimmed.to_string().into());
144 }
145
146 buffer.clear();
147 };
148
149 for ch in css_name.chars() {
150 match (ch, quote_char) {
151 ('"' | '\'', None) => {
152 quote_char = Some(ch);
153 }
154 (_, Some(q)) if ch == q => {
155 quote_char = None;
156 }
157 (',', None) => {
158 add_font(&mut name_buffer);
159 }
160 _ => {
161 name_buffer.push(ch);
162 }
163 }
164 }
165
166 add_font(&mut name_buffer);
167 if fonts.is_empty() {
168 return (None, None);
169 }
170 (Some(fonts.remove(0)), skip_default(fonts))
171 }
172
173 pub fn settings_content(&self) -> SettingsContent {
174 SettingsContent {
175 agent: self.agent_settings_content(),
176 agent_servers: None,
177 audio: None,
178 auto_update: None,
179 base_keymap: Some(BaseKeymapContent::VSCode),
180 calls: None,
181 collaboration_panel: None,
182 debugger: None,
183 diagnostics: None,
184 editor: self.editor_settings_content(),
185 extension: ExtensionSettingsContent::default(),
186 file_finder: None,
187 git: self.git_settings_content(),
188 git_panel: self.git_panel_settings_content(),
189 global_lsp_settings: skip_default(GlobalLspSettingsContent {
190 semantic_token_rules: self.semantic_token_rules(),
191 ..GlobalLspSettingsContent::default()
192 }),
193 helix_mode: None,
194 image_viewer: None,
195 journal: None,
196 language_models: None,
197 line_indicator_format: None,
198 log: None,
199 message_editor: None,
200 node: self.node_binary_settings(),
201 notification_panel: None,
202 outline_panel: self.outline_panel_settings_content(),
203 preview_tabs: self.preview_tabs_settings_content(),
204 project: self.project_settings_content(),
205 project_panel: self.project_panel_settings_content(),
206 proxy: self.read_string("http.proxy"),
207 remote: RemoteSettingsContent::default(),
208 repl: None,
209 server_url: None,
210 session: None,
211 status_bar: self.status_bar_settings_content(),
212 tab_bar: self.tab_bar_settings_content(),
213 tabs: self.item_settings_content(),
214 telemetry: self.telemetry_settings_content(),
215 terminal: self.terminal_settings_content(),
216 theme: Box::new(self.theme_settings_content()),
217 title_bar: None,
218 vim: None,
219 vim_mode: None,
220 workspace: self.workspace_settings_content(),
221 which_key: None,
222 }
223 }
224
225 fn agent_settings_content(&self) -> Option<AgentSettingsContent> {
226 let enabled = self.read_bool("chat.agent.enabled");
227 skip_default(AgentSettingsContent {
228 enabled: enabled,
229 button: enabled,
230 ..Default::default()
231 })
232 }
233
234 fn editor_settings_content(&self) -> EditorSettingsContent {
235 EditorSettingsContent {
236 auto_signature_help: self.read_bool("editor.parameterHints.enabled"),
237 autoscroll_on_clicks: None,
238 cursor_blink: self.read_enum("editor.cursorBlinking", |s| match s {
239 "blink" | "phase" | "expand" | "smooth" => Some(true),
240 "solid" => Some(false),
241 _ => None,
242 }),
243 cursor_shape: self.read_enum("editor.cursorStyle", |s| match s {
244 "block" => Some(CursorShape::Block),
245 "block-outline" => Some(CursorShape::Hollow),
246 "line" | "line-thin" => Some(CursorShape::Bar),
247 "underline" | "underline-thin" => Some(CursorShape::Underline),
248 _ => None,
249 }),
250 current_line_highlight: self.read_enum("editor.renderLineHighlight", |s| match s {
251 "gutter" => Some(CurrentLineHighlight::Gutter),
252 "line" => Some(CurrentLineHighlight::Line),
253 "all" => Some(CurrentLineHighlight::All),
254 _ => None,
255 }),
256 diagnostics_max_severity: None,
257 double_click_in_multibuffer: None,
258 drag_and_drop_selection: None,
259 excerpt_context_lines: None,
260 expand_excerpt_lines: None,
261 fast_scroll_sensitivity: self.read_f32("editor.fastScrollSensitivity"),
262 sticky_scroll: self.sticky_scroll_content(),
263 go_to_definition_fallback: None,
264 gutter: self.gutter_content(),
265 hide_mouse: None,
266 horizontal_scroll_margin: None,
267 hover_popover_delay: self.read_u64("editor.hover.delay").map(Into::into),
268 hover_popover_enabled: self.read_bool("editor.hover.enabled"),
269 inline_code_actions: None,
270 jupyter: None,
271 lsp_document_colors: None,
272 lsp_highlight_debounce: None,
273 middle_click_paste: None,
274 minimap: self.minimap_content(),
275 minimum_contrast_for_highlights: None,
276 multi_cursor_modifier: self.read_enum("editor.multiCursorModifier", |s| match s {
277 "ctrlCmd" => Some(MultiCursorModifier::CmdOrCtrl),
278 "alt" => Some(MultiCursorModifier::Alt),
279 _ => None,
280 }),
281 redact_private_values: None,
282 relative_line_numbers: self.read_enum("editor.lineNumbers", |s| match s {
283 "relative" => Some(RelativeLineNumbers::Enabled),
284 _ => None,
285 }),
286 rounded_selection: self.read_bool("editor.roundedSelection"),
287 scroll_beyond_last_line: None,
288 scroll_sensitivity: self.read_f32("editor.mouseWheelScrollSensitivity"),
289 scrollbar: self.scrollbar_content(),
290 search: self.search_content(),
291 search_wrap: None,
292 seed_search_query_from_cursor: self.read_enum(
293 "editor.find.seedSearchStringFromSelection",
294 |s| match s {
295 "always" => Some(SeedQuerySetting::Always),
296 "selection" => Some(SeedQuerySetting::Selection),
297 "never" => Some(SeedQuerySetting::Never),
298 _ => None,
299 },
300 ),
301 selection_highlight: self.read_bool("editor.selectionHighlight"),
302 show_signature_help_after_edits: self.read_bool("editor.parameterHints.enabled"),
303 snippet_sort_order: None,
304 toolbar: None,
305 use_smartcase_search: self.read_bool("search.smartCase"),
306 vertical_scroll_margin: self.read_f32("editor.cursorSurroundingLines"),
307 completion_menu_scrollbar: None,
308 completion_detail_alignment: None,
309 diff_view_style: None,
310 }
311 }
312
313 fn sticky_scroll_content(&self) -> Option<StickyScrollContent> {
314 skip_default(StickyScrollContent {
315 enabled: self.read_bool("editor.stickyScroll.enabled"),
316 })
317 }
318
319 fn gutter_content(&self) -> Option<GutterContent> {
320 skip_default(GutterContent {
321 line_numbers: self.read_enum("editor.lineNumbers", |s| match s {
322 "on" | "relative" => Some(true),
323 "off" => Some(false),
324 _ => None,
325 }),
326 min_line_number_digits: None,
327 runnables: None,
328 breakpoints: None,
329 folds: self.read_enum("editor.showFoldingControls", |s| match s {
330 "always" | "mouseover" => Some(true),
331 "never" => Some(false),
332 _ => None,
333 }),
334 })
335 }
336
337 fn scrollbar_content(&self) -> Option<ScrollbarContent> {
338 let scrollbar_axes = skip_default(ScrollbarAxesContent {
339 horizontal: self.read_enum("editor.scrollbar.horizontal", |s| match s {
340 "auto" | "visible" => Some(true),
341 "hidden" => Some(false),
342 _ => None,
343 }),
344 vertical: self.read_enum("editor.scrollbar.vertical", |s| match s {
345 "auto" | "visible" => Some(true),
346 "hidden" => Some(false),
347 _ => None,
348 }),
349 })?;
350
351 Some(ScrollbarContent {
352 axes: Some(scrollbar_axes),
353 ..Default::default()
354 })
355 }
356
357 fn search_content(&self) -> Option<SearchSettingsContent> {
358 skip_default(SearchSettingsContent {
359 include_ignored: self.read_bool("search.useIgnoreFiles"),
360 search_on_input: self.read_bool("search.searchOnType"),
361 ..SearchSettingsContent::default()
362 })
363 }
364
365 fn semantic_token_rules(&self) -> Option<SemanticTokenRules> {
366 let customizations = self
367 .read_value("editor.semanticTokenColorCustomizations")?
368 .as_object()?;
369
370 skip_default(SemanticTokenRules {
371 rules: customizations
372 .get("rules")
373 .and_then(|v| {
374 Some(
375 v.as_object()?
376 .iter()
377 .filter_map(|(k, v)| {
378 let v = v.as_object()?;
379
380 let mut underline = v
381 .get("underline")
382 .and_then(|b| b.as_bool())
383 .unwrap_or(false);
384 let strikethrough = v
385 .get("strikethrough")
386 .and_then(|b| b.as_bool())
387 .unwrap_or(false);
388 let mut font_weight =
389 v.get("bold").and_then(|b| b.as_bool()).map(|b| {
390 if b {
391 SemanticTokenFontWeight::Bold
392 } else {
393 SemanticTokenFontWeight::Normal
394 }
395 });
396 let mut font_style =
397 v.get("italic").and_then(|b| b.as_bool()).map(|b| {
398 if b {
399 SemanticTokenFontStyle::Italic
400 } else {
401 SemanticTokenFontStyle::Normal
402 }
403 });
404
405 match v.get("fontStyle").and_then(|s| s.as_str()).unwrap_or("") {
406 "bold" => {
407 font_style = Some(SemanticTokenFontStyle::Normal);
408 font_weight = Some(SemanticTokenFontWeight::Bold);
409 }
410 "italic" => {
411 font_style = Some(SemanticTokenFontStyle::Italic);
412 font_weight = Some(SemanticTokenFontWeight::Normal);
413 }
414 "underline" => {
415 underline = true;
416 }
417 "bold italic" | "italic bold" => {
418 font_style = Some(SemanticTokenFontStyle::Italic);
419 font_weight = Some(SemanticTokenFontWeight::Bold);
420 }
421 "normal" => {
422 font_style = Some(SemanticTokenFontStyle::Normal);
423 font_weight = Some(SemanticTokenFontWeight::Normal);
424 }
425 _ => {}
426 }
427
428 let foreground = v
429 .get("foreground")
430 .and_then(|v| Rgba::try_from(v.as_str()?).ok())
431 .map(|s| s.to_owned());
432 let background = v
433 .get("background")
434 .and_then(|v| Rgba::try_from(v.as_str()?).ok())
435 .map(|s| s.to_owned());
436
437 Some(SemanticTokenRule {
438 token_type: Some(k.clone()),
439 token_modifiers: vec![],
440 style: vec![],
441 underline: if underline {
442 Some(SemanticTokenColorOverride::InheritForeground(true))
443 } else {
444 None
445 },
446 strikethrough: if strikethrough {
447 Some(SemanticTokenColorOverride::InheritForeground(true))
448 } else {
449 None
450 },
451 foreground_color: foreground,
452 background_color: background,
453 font_weight,
454 font_style,
455 })
456 })
457 .collect(),
458 )
459 })
460 .unwrap_or_default(),
461 })
462 }
463
464 fn minimap_content(&self) -> Option<MinimapContent> {
465 let minimap_enabled = self.read_bool("editor.minimap.enabled");
466 let autohide = self.read_bool("editor.minimap.autohide");
467 let show = match (minimap_enabled, autohide) {
468 (Some(true), Some(false)) => Some(ShowMinimap::Always),
469 (Some(true), _) => Some(ShowMinimap::Auto),
470 (Some(false), _) => Some(ShowMinimap::Never),
471 _ => None,
472 };
473
474 skip_default(MinimapContent {
475 show,
476 thumb: self.read_enum("editor.minimap.showSlider", |s| match s {
477 "always" => Some(MinimapThumb::Always),
478 "mouseover" => Some(MinimapThumb::Hover),
479 _ => None,
480 }),
481 max_width_columns: self
482 .read_u32("editor.minimap.maxColumn")
483 .and_then(|v| NonZeroU32::new(v)),
484 ..Default::default()
485 })
486 }
487
488 fn git_panel_settings_content(&self) -> Option<GitPanelSettingsContent> {
489 skip_default(GitPanelSettingsContent {
490 button: self.read_bool("git.enabled"),
491 fallback_branch_name: self.read_string("git.defaultBranchName"),
492 ..Default::default()
493 })
494 }
495
496 fn project_settings_content(&self) -> ProjectSettingsContent {
497 ProjectSettingsContent {
498 all_languages: AllLanguageSettingsContent {
499 edit_predictions: self.edit_predictions_settings_content(),
500 defaults: self.default_language_settings_content(),
501 languages: Default::default(),
502 file_types: self.file_types(),
503 },
504 worktree: self.worktree_settings_content(),
505 lsp: Default::default(),
506 terminal: None,
507 dap: Default::default(),
508 context_servers: self.context_servers(),
509 context_server_timeout: None,
510 load_direnv: None,
511 slash_commands: None,
512 git_hosting_providers: None,
513 disable_ai: None,
514 }
515 }
516
517 fn default_language_settings_content(&self) -> LanguageSettingsContent {
518 LanguageSettingsContent {
519 allow_rewrap: None,
520 always_treat_brackets_as_autoclosed: None,
521 auto_indent: None,
522 auto_indent_on_paste: self.read_bool("editor.formatOnPaste"),
523 code_actions_on_format: None,
524 completions: skip_default(CompletionSettingsContent {
525 words: self.read_bool("editor.suggest.showWords").map(|b| {
526 if b {
527 WordsCompletionMode::Enabled
528 } else {
529 WordsCompletionMode::Disabled
530 }
531 }),
532 ..Default::default()
533 }),
534 debuggers: None,
535 edit_predictions_disabled_in: None,
536 enable_language_server: None,
537 ensure_final_newline_on_save: self.read_bool("files.insertFinalNewline"),
538 extend_comment_on_newline: None,
539 extend_list_on_newline: None,
540 indent_list_on_tab: None,
541 format_on_save: self.read_bool("editor.guides.formatOnSave").map(|b| {
542 if b {
543 FormatOnSave::On
544 } else {
545 FormatOnSave::Off
546 }
547 }),
548 formatter: None,
549 hard_tabs: self.read_bool("editor.insertSpaces").map(|v| !v),
550 indent_guides: skip_default(IndentGuideSettingsContent {
551 enabled: self.read_bool("editor.guides.indentation"),
552 ..Default::default()
553 }),
554 inlay_hints: None,
555 jsx_tag_auto_close: None,
556 language_servers: None,
557 semantic_tokens: self
558 .read_bool("editor.semanticHighlighting.enabled")
559 .map(|enabled| {
560 if enabled {
561 SemanticTokens::Full
562 } else {
563 SemanticTokens::Off
564 }
565 }),
566 document_folding_ranges: None,
567 document_symbols: None,
568 linked_edits: self.read_bool("editor.linkedEditing"),
569 preferred_line_length: self.read_u32("editor.wordWrapColumn"),
570 prettier: None,
571 remove_trailing_whitespace_on_save: self.read_bool("editor.trimAutoWhitespace"),
572 show_completion_documentation: None,
573 colorize_brackets: self.read_bool("editor.bracketPairColorization.enabled"),
574 show_completions_on_input: self.read_bool("editor.suggestOnTriggerCharacters"),
575 show_edit_predictions: self.read_bool("editor.inlineSuggest.enabled"),
576 show_whitespaces: self.read_enum("editor.renderWhitespace", |s| {
577 Some(match s {
578 "boundary" => ShowWhitespaceSetting::Boundary,
579 "trailing" => ShowWhitespaceSetting::Trailing,
580 "selection" => ShowWhitespaceSetting::Selection,
581 "all" => ShowWhitespaceSetting::All,
582 _ => ShowWhitespaceSetting::None,
583 })
584 }),
585 show_wrap_guides: None,
586 soft_wrap: self.read_enum("editor.wordWrap", |s| match s {
587 "on" => Some(SoftWrap::EditorWidth),
588 "wordWrapColumn" => Some(SoftWrap::PreferLine),
589 "bounded" => Some(SoftWrap::Bounded),
590 "off" => Some(SoftWrap::None),
591 _ => None,
592 }),
593 tab_size: self
594 .read_u32("editor.tabSize")
595 .and_then(|n| NonZeroU32::new(n)),
596 tasks: None,
597 use_auto_surround: self.read_enum("editor.autoSurround", |s| match s {
598 "languageDefined" | "quotes" | "brackets" => Some(true),
599 "never" => Some(false),
600 _ => None,
601 }),
602 use_autoclose: None,
603 use_on_type_format: self.read_bool("editor.formatOnType"),
604 whitespace_map: None,
605 wrap_guides: self
606 .read_value("editor.rulers")
607 .and_then(|v| v.as_array())
608 .map(|v| {
609 v.iter()
610 .flat_map(|n| n.as_u64().map(|n| n as usize))
611 .collect()
612 }),
613 word_diff_enabled: None,
614 }
615 }
616
617 fn file_types(&self) -> Option<HashMap<Arc<str>, ExtendingVec<String>>> {
618 // vscodes file association map is inverted from ours, so we flip the mapping before merging
619 let mut associations: HashMap<Arc<str>, ExtendingVec<String>> = HashMap::default();
620 let map = self.read_value("files.associations")?.as_object()?;
621 for (k, v) in map {
622 let Some(v) = v.as_str() else { continue };
623 associations.entry(v.into()).or_default().0.push(k.clone());
624 }
625 skip_default(associations)
626 }
627
628 fn edit_predictions_settings_content(&self) -> Option<EditPredictionSettingsContent> {
629 let disabled_globs = self
630 .read_value("cursor.general.globalCursorIgnoreList")?
631 .as_array()?;
632
633 skip_default(EditPredictionSettingsContent {
634 disabled_globs: skip_default(
635 disabled_globs
636 .iter()
637 .filter_map(|glob| glob.as_str())
638 .map(|s| s.to_string())
639 .collect(),
640 ),
641 ..Default::default()
642 })
643 }
644
645 fn outline_panel_settings_content(&self) -> Option<OutlinePanelSettingsContent> {
646 skip_default(OutlinePanelSettingsContent {
647 file_icons: self.read_bool("outline.icons"),
648 folder_icons: self.read_bool("outline.icons"),
649 git_status: self.read_bool("git.decorations.enabled"),
650 ..Default::default()
651 })
652 }
653
654 fn node_binary_settings(&self) -> Option<NodeBinarySettings> {
655 // this just sets the binary name instead of a full path so it relies on path lookup
656 // resolving to the one you want
657 skip_default(NodeBinarySettings {
658 npm_path: self.read_enum("npm.packageManager", |s| match s {
659 v @ ("npm" | "yarn" | "bun" | "pnpm") => Some(v.to_owned()),
660 _ => None,
661 }),
662 ..Default::default()
663 })
664 }
665
666 fn git_settings_content(&self) -> Option<GitSettings> {
667 let inline_blame = self.read_bool("git.blame.editorDecoration.enabled")?;
668 skip_default(GitSettings {
669 inline_blame: Some(InlineBlameSettings {
670 enabled: Some(inline_blame),
671 ..Default::default()
672 }),
673 ..Default::default()
674 })
675 }
676
677 fn context_servers(&self) -> HashMap<Arc<str>, ContextServerSettingsContent> {
678 #[derive(Deserialize)]
679 struct VsCodeContextServerCommand {
680 command: PathBuf,
681 args: Option<Vec<String>>,
682 env: Option<HashMap<String, String>>,
683 // note: we don't support envFile and type
684 }
685 let Some(mcp) = self.read_value("mcp").and_then(|v| v.as_object()) else {
686 return Default::default();
687 };
688 mcp.iter()
689 .filter_map(|(k, v)| {
690 Some((
691 k.clone().into(),
692 ContextServerSettingsContent::Stdio {
693 enabled: true,
694 remote: false,
695 command: serde_json::from_value::<VsCodeContextServerCommand>(v.clone())
696 .ok()
697 .map(|cmd| ContextServerCommand {
698 path: cmd.command,
699 args: cmd.args.unwrap_or_default(),
700 env: cmd.env,
701 timeout: None,
702 })?,
703 },
704 ))
705 })
706 .collect()
707 }
708
709 fn item_settings_content(&self) -> Option<ItemSettingsContent> {
710 skip_default(ItemSettingsContent {
711 git_status: self.read_bool("git.decorations.enabled"),
712 close_position: self.read_enum("workbench.editor.tabActionLocation", |s| match s {
713 "right" => Some(ClosePosition::Right),
714 "left" => Some(ClosePosition::Left),
715 _ => None,
716 }),
717 file_icons: self.read_bool("workbench.editor.showIcons"),
718 activate_on_close: self
719 .read_bool("workbench.editor.focusRecentEditorAfterClose")
720 .map(|b| {
721 if b {
722 ActivateOnClose::History
723 } else {
724 ActivateOnClose::LeftNeighbour
725 }
726 }),
727 show_diagnostics: None,
728 show_close_button: self
729 .read_bool("workbench.editor.tabActionCloseVisibility")
730 .map(|b| {
731 if b {
732 ShowCloseButton::Always
733 } else {
734 ShowCloseButton::Hidden
735 }
736 }),
737 })
738 }
739
740 fn preview_tabs_settings_content(&self) -> Option<PreviewTabsSettingsContent> {
741 skip_default(PreviewTabsSettingsContent {
742 enabled: self.read_bool("workbench.editor.enablePreview"),
743 enable_preview_from_project_panel: None,
744 enable_preview_from_file_finder: self
745 .read_bool("workbench.editor.enablePreviewFromQuickOpen"),
746 enable_preview_from_multibuffer: None,
747 enable_preview_multibuffer_from_code_navigation: None,
748 enable_preview_file_from_code_navigation: None,
749 enable_keep_preview_on_code_navigation: self
750 .read_bool("workbench.editor.enablePreviewFromCodeNavigation"),
751 })
752 }
753
754 fn tab_bar_settings_content(&self) -> Option<TabBarSettingsContent> {
755 skip_default(TabBarSettingsContent {
756 show: self.read_enum("workbench.editor.showTabs", |s| match s {
757 "multiple" => Some(true),
758 "single" | "none" => Some(false),
759 _ => None,
760 }),
761 show_nav_history_buttons: None,
762 show_tab_bar_buttons: self
763 .read_str("workbench.editor.editorActionsLocation")
764 .and_then(|str| if str == "hidden" { Some(false) } else { None }),
765 show_pinned_tabs_in_separate_row: None,
766 })
767 }
768
769 fn status_bar_settings_content(&self) -> Option<StatusBarSettingsContent> {
770 skip_default(StatusBarSettingsContent {
771 show: self.read_bool("workbench.statusBar.visible"),
772 active_language_button: None,
773 cursor_position_button: None,
774 line_endings_button: None,
775 active_encoding_button: None,
776 })
777 }
778
779 fn project_panel_settings_content(&self) -> Option<ProjectPanelSettingsContent> {
780 let mut project_panel_settings = ProjectPanelSettingsContent {
781 auto_fold_dirs: self.read_bool("explorer.compactFolders"),
782 auto_reveal_entries: self.read_bool("explorer.autoReveal"),
783 bold_folder_labels: None,
784 button: None,
785 default_width: None,
786 dock: None,
787 drag_and_drop: None,
788 entry_spacing: None,
789 file_icons: None,
790 folder_icons: None,
791 git_status: self.read_bool("git.decorations.enabled"),
792 hide_gitignore: self.read_bool("explorer.excludeGitIgnore"),
793 hide_hidden: None,
794 hide_root: None,
795 indent_guides: None,
796 indent_size: None,
797 scrollbar: None,
798 show_diagnostics: self
799 .read_bool("problems.decorations.enabled")
800 .and_then(|b| if b { Some(ShowDiagnostics::Off) } else { None }),
801 sort_mode: None,
802 starts_open: None,
803 sticky_scroll: None,
804 auto_open: None,
805 };
806
807 if let (Some(false), Some(false)) = (
808 self.read_bool("explorer.decorations.badges"),
809 self.read_bool("explorer.decorations.colors"),
810 ) {
811 project_panel_settings.git_status = Some(false);
812 project_panel_settings.show_diagnostics = Some(ShowDiagnostics::Off);
813 }
814
815 skip_default(project_panel_settings)
816 }
817
818 fn telemetry_settings_content(&self) -> Option<TelemetrySettingsContent> {
819 self.read_enum("telemetry.telemetryLevel", |level| {
820 let (metrics, diagnostics) = match level {
821 "all" => (true, true),
822 "error" | "crash" => (false, true),
823 "off" => (false, false),
824 _ => return None,
825 };
826 Some(TelemetrySettingsContent {
827 metrics: Some(metrics),
828 diagnostics: Some(diagnostics),
829 })
830 })
831 }
832
833 fn terminal_settings_content(&self) -> Option<TerminalSettingsContent> {
834 let (font_family, font_fallbacks) = self.read_fonts("terminal.integrated.fontFamily");
835 skip_default(TerminalSettingsContent {
836 alternate_scroll: None,
837 blinking: self
838 .read_bool("terminal.integrated.cursorBlinking")
839 .map(|b| {
840 if b {
841 TerminalBlink::On
842 } else {
843 TerminalBlink::Off
844 }
845 }),
846 button: None,
847 copy_on_select: self.read_bool("terminal.integrated.copyOnSelection"),
848 cursor_shape: self.read_enum("terminal.integrated.cursorStyle", |s| match s {
849 "block" => Some(CursorShapeContent::Block),
850 "line" => Some(CursorShapeContent::Bar),
851 "underline" => Some(CursorShapeContent::Underline),
852 _ => None,
853 }),
854 default_height: None,
855 default_width: None,
856 dock: None,
857 font_fallbacks,
858 font_family,
859 font_features: None,
860 font_size: self
861 .read_f32("terminal.integrated.fontSize")
862 .map(FontSize::from),
863 font_weight: None,
864 keep_selection_on_copy: None,
865 line_height: self
866 .read_f32("terminal.integrated.lineHeight")
867 .map(|lh| TerminalLineHeight::Custom(lh)),
868 max_scroll_history_lines: self.read_usize("terminal.integrated.scrollback"),
869 minimum_contrast: None,
870 option_as_meta: self.read_bool("terminal.integrated.macOptionIsMeta"),
871 project: self.project_terminal_settings_content(),
872 scrollbar: None,
873 scroll_multiplier: None,
874 toolbar: None,
875 })
876 }
877
878 fn project_terminal_settings_content(&self) -> ProjectTerminalSettingsContent {
879 #[cfg(target_os = "windows")]
880 let platform = "windows";
881 #[cfg(target_os = "linux")]
882 let platform = "linux";
883 #[cfg(target_os = "macos")]
884 let platform = "osx";
885 #[cfg(target_os = "freebsd")]
886 let platform = "freebsd";
887 let env = self
888 .read_value(&format!("terminal.integrated.env.{platform}"))
889 .and_then(|v| v.as_object())
890 .map(|v| {
891 v.iter()
892 .map(|(k, v)| (k.clone(), v.to_string()))
893 // zed does not support substitutions, so this can break env vars
894 .filter(|(_, v)| !v.contains('$'))
895 .collect()
896 });
897
898 ProjectTerminalSettingsContent {
899 // TODO: handle arguments
900 shell: self
901 .read_string(&format!("terminal.integrated.{platform}Exec"))
902 .map(|s| Shell::Program(s)),
903 working_directory: None,
904 env,
905 detect_venv: None,
906 path_hyperlink_regexes: None,
907 path_hyperlink_timeout_ms: None,
908 }
909 }
910
911 fn theme_settings_content(&self) -> ThemeSettingsContent {
912 let (buffer_font_family, buffer_font_fallbacks) = self.read_fonts("editor.fontFamily");
913 ThemeSettingsContent {
914 ui_font_size: None,
915 ui_font_family: None,
916 ui_font_fallbacks: None,
917 ui_font_features: None,
918 ui_font_weight: None,
919 buffer_font_family,
920 buffer_font_fallbacks,
921 buffer_font_size: self.read_f32("editor.fontSize").map(FontSize::from),
922 buffer_font_weight: self.read_f32("editor.fontWeight").map(FontWeightContent),
923 buffer_line_height: None,
924 buffer_font_features: None,
925 agent_ui_font_size: None,
926 agent_buffer_font_size: None,
927 theme: None,
928 icon_theme: None,
929 ui_density: None,
930 unnecessary_code_fade: None,
931 experimental_theme_overrides: None,
932 theme_overrides: Default::default(),
933 }
934 }
935
936 fn workspace_settings_content(&self) -> WorkspaceSettingsContent {
937 WorkspaceSettingsContent {
938 active_pane_modifiers: self.active_pane_modifiers(),
939 text_rendering_mode: None,
940 autosave: self.read_enum("files.autoSave", |s| match s {
941 "off" => Some(AutosaveSetting::Off),
942 "afterDelay" => Some(AutosaveSetting::AfterDelay {
943 milliseconds: self
944 .read_value("files.autoSaveDelay")
945 .and_then(|v| v.as_u64())
946 .unwrap_or(1000)
947 .into(),
948 }),
949 "onFocusChange" => Some(AutosaveSetting::OnFocusChange),
950 "onWindowChange" => Some(AutosaveSetting::OnWindowChange),
951 _ => None,
952 }),
953 bottom_dock_layout: None,
954 centered_layout: None,
955 close_on_file_delete: None,
956 close_panel_on_toggle: None,
957 command_aliases: Default::default(),
958 confirm_quit: self.read_enum("window.confirmBeforeClose", |s| match s {
959 "always" | "keyboardOnly" => Some(true),
960 "never" => Some(false),
961 _ => None,
962 }),
963 drop_target_size: None,
964 // workbench.editor.limit contains "enabled", "value", and "perEditorGroup"
965 // our semantics match if those are set to true, some N, and true respectively.
966 // we'll ignore "perEditorGroup" for now since we only support a global max
967 max_tabs: if self.read_bool("workbench.editor.limit.enabled") == Some(true) {
968 self.read_usize("workbench.editor.limit.value")
969 .and_then(|n| NonZeroUsize::new(n))
970 } else {
971 None
972 },
973 on_last_window_closed: None,
974 pane_split_direction_horizontal: None,
975 pane_split_direction_vertical: None,
976 resize_all_panels_in_dock: None,
977 restore_on_file_reopen: self.read_bool("workbench.editor.restoreViewState"),
978 restore_on_startup: None,
979 window_decorations: None,
980 show_call_status_icon: None,
981 use_system_path_prompts: self.read_bool("files.simpleDialog.enable"),
982 use_system_prompts: None,
983 use_system_window_tabs: self.read_bool("window.nativeTabs"),
984 when_closing_with_no_tabs: self.read_bool("window.closeWhenEmpty").map(|b| {
985 if b {
986 CloseWindowWhenNoItems::CloseWindow
987 } else {
988 CloseWindowWhenNoItems::KeepWindowOpen
989 }
990 }),
991 zoomed_padding: None,
992 }
993 }
994
995 fn active_pane_modifiers(&self) -> Option<ActivePaneModifiers> {
996 if self.read_bool("accessibility.dimUnfocused.enabled") == Some(true)
997 && let Some(opacity) = self.read_f32("accessibility.dimUnfocused.opacity")
998 {
999 Some(ActivePaneModifiers {
1000 border_size: None,
1001 inactive_opacity: Some(InactiveOpacity(opacity)),
1002 })
1003 } else {
1004 None
1005 }
1006 }
1007
1008 fn worktree_settings_content(&self) -> WorktreeSettingsContent {
1009 WorktreeSettingsContent {
1010 project_name: None,
1011 prevent_sharing_in_public_channels: false,
1012 file_scan_exclusions: self
1013 .read_value("files.watcherExclude")
1014 .and_then(|v| v.as_array())
1015 .map(|v| {
1016 v.iter()
1017 .filter_map(|n| n.as_str().map(str::to_owned))
1018 .collect::<Vec<_>>()
1019 })
1020 .filter(|r| !r.is_empty()),
1021 file_scan_inclusions: self
1022 .read_value("files.watcherInclude")
1023 .and_then(|v| v.as_array())
1024 .map(|v| {
1025 v.iter()
1026 .filter_map(|n| n.as_str().map(str::to_owned))
1027 .collect::<Vec<_>>()
1028 })
1029 .filter(|r| !r.is_empty()),
1030 private_files: None,
1031 hidden_files: None,
1032 read_only_files: self
1033 .read_value("files.readonlyExclude")
1034 .and_then(|v| v.as_object())
1035 .map(|v| {
1036 v.iter()
1037 .filter_map(|(k, v)| {
1038 if v.as_bool().unwrap_or(false) {
1039 Some(k.to_owned())
1040 } else {
1041 None
1042 }
1043 })
1044 .collect::<Vec<_>>()
1045 })
1046 .filter(|r| !r.is_empty()),
1047 }
1048 }
1049}
1050
1051fn skip_default<T: Default + PartialEq>(value: T) -> Option<T> {
1052 if value == T::default() {
1053 None
1054 } else {
1055 Some(value)
1056 }
1057}