Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

65.7 KB
Raw Blame
use crate::*;
use anyhow::{Context as _, Result, anyhow};
use collections::HashMap;
use fs::Fs;
use gpui::Rgba;
use paths::{cursor_settings_file_paths, vscode_settings_file_paths};
use serde::Deserialize;
use serde_json::{Map, Value};
use std::{
    num::{NonZeroU32, NonZeroUsize},
    path::{Path, PathBuf},
    sync::Arc,
};

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum VsCodeSettingsSource {
    VsCode,
    Cursor,
}

impl std::fmt::Display for VsCodeSettingsSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            VsCodeSettingsSource::VsCode => write!(f, "VS Code"),
            VsCodeSettingsSource::Cursor => write!(f, "Cursor"),
        }
    }
}

pub struct VsCodeSettings {
    pub source: VsCodeSettingsSource,
    pub path: Arc<Path>,
    content: Map<String, Value>,
}

impl VsCodeSettings {
    #[cfg(any(test, feature = "test-support"))]
    pub fn from_str(content: &str, source: VsCodeSettingsSource) -> Result<Self> {
        Ok(Self {
            source,
            path: Path::new("/example-path/Code/User/settings.json").into(),
            content: serde_json_lenient::from_str(content)?,
        })
    }

    pub async fn load_user_settings(source: VsCodeSettingsSource, fs: Arc<dyn Fs>) -> Result<Self> {
        let candidate_paths = match source {
            VsCodeSettingsSource::VsCode => vscode_settings_file_paths(),
            VsCodeSettingsSource::Cursor => cursor_settings_file_paths(),
        };
        let mut path = None;
        for candidate_path in candidate_paths.iter() {
            if fs.is_file(candidate_path).await {
                path = Some(candidate_path.clone());
            }
        }
        let Some(path) = path else {
            return Err(anyhow!(
                "No settings file found, expected to find it in one of the following paths:\n{}",
                candidate_paths
                    .into_iter()
                    .map(|path| path.to_string_lossy().into_owned())
                    .collect::<Vec<_>>()
                    .join("\n")
            ));
        };
        let content = fs.load(&path).await.with_context(|| {
            format!(
                "Error loading {} settings file from {}",
                source,
                path.display()
            )
        })?;
        let content = serde_json_lenient::from_str(&content).with_context(|| {
            format!(
                "Error parsing {} settings file from {}",
                source,
                path.display()
            )
        })?;
        Ok(Self {
            source,
            path: path.into(),
            content,
        })
    }

    fn read_value(&self, setting: &str) -> Option<&Value> {
        self.content.get(setting)
    }

    fn read_str(&self, setting: &str) -> Option<&str> {
        self.read_value(setting).and_then(|v| v.as_str())
    }

    fn read_string(&self, setting: &str) -> Option<String> {
        self.read_value(setting)
            .and_then(|v| v.as_str())
            .map(|s| s.to_owned())
    }

    fn read_window_title_format(&self) -> Option<String> {
        self.read_string("window.title")
            .map(|template| translate_vscode_window_title_format(&template))
            // If every placeholder is dropped during translation, keep Zed's
            // default title behavior instead of importing a template that
            // renders as nothing but whitespace.
            .filter(|template| !template.trim().is_empty())
    }

    fn read_bool(&self, setting: &str) -> Option<bool> {
        self.read_value(setting).and_then(|v| v.as_bool())
    }

    fn read_f32(&self, setting: &str) -> Option<f32> {
        self.read_value(setting)
            .and_then(|v| v.as_f64())
            .map(|v| v as f32)
    }

    fn read_u64(&self, setting: &str) -> Option<u64> {
        self.read_value(setting).and_then(|v| v.as_u64())
    }

    fn read_usize(&self, setting: &str) -> Option<usize> {
        self.read_value(setting)
            .and_then(|v| v.as_u64())
            .and_then(|v| v.try_into().ok())
    }

    fn read_u32(&self, setting: &str) -> Option<u32> {
        self.read_value(setting)
            .and_then(|v| v.as_u64())
            .and_then(|v| v.try_into().ok())
    }

    fn read_enum<T>(&self, key: &str, f: impl FnOnce(&str) -> Option<T>) -> Option<T> {
        self.content.get(key).and_then(Value::as_str).and_then(f)
    }

    fn read_fonts(&self, key: &str) -> (Option<FontFamilyName>, Option<Vec<FontFamilyName>>) {
        let Some(css_name) = self.content.get(key).and_then(Value::as_str) else {
            return (None, None);
        };

        let mut name_buffer = String::new();
        let mut quote_char: Option<char> = None;
        let mut fonts = Vec::new();
        let mut add_font = |buffer: &mut String| {
            let trimmed = buffer.trim();
            if !trimmed.is_empty() {
                fonts.push(trimmed.to_string().into());
            }

            buffer.clear();
        };

        for ch in css_name.chars() {
            match (ch, quote_char) {
                ('"' | '\'', None) => {
                    quote_char = Some(ch);
                }
                (_, Some(q)) if ch == q => {
                    quote_char = None;
                }
                (',', None) => {
                    add_font(&mut name_buffer);
                }
                _ => {
                    name_buffer.push(ch);
                }
            }
        }

        add_font(&mut name_buffer);
        if fonts.is_empty() {
            return (None, None);
        }
        (Some(fonts.remove(0)), skip_default(fonts))
    }

    pub fn settings_content(&self) -> SettingsContent {
        SettingsContent {
            agent: self.agent_settings_content(),
            agent_servers: None,
            audio: None,
            auto_update: None,
            base_keymap: Some(BaseKeymapContent::VSCode),
            calls: None,
            collaboration_panel: None,
            command_palette: self
                .read_u64("workbench.commandPalette.history")
                .map(|history| CommandPaletteSettingsContent {
                    use_command_history: Some(history > 0),
                }),
            copilot: None,
            credentials_url: None,
            debugger: None,
            diagnostics: None,
            editor: self.editor_settings_content(),
            extension: ExtensionSettingsContent::default(),
            call_hierarchy: None,
            file_finder: None,
            git: self.git_settings_content(),
            git_panel: self.git_panel_settings_content(),
            git_graph: None,
            global_lsp_settings: skip_default(GlobalLspSettingsContent {
                semantic_token_rules: self.semantic_token_rules(),
                ..GlobalLspSettingsContent::default()
            }),
            helix_mode: None,
            hide_mouse: None,
            image_viewer: None,
            markdown_preview: None,
            journal: None,
            language_models: None,
            line_indicator_format: None,
            log: None,
            node: self.node_binary_settings(),

            outline_panel: self.outline_panel_settings_content(),
            preview_tabs: self.preview_tabs_settings_content(),
            project: self.project_settings_content(),
            project_panel: self.project_panel_settings_content(),
            proxy: self.read_string("http.proxy"),
            reduce_motion: self.read_enum("workbench.reduceMotion", |s| match s {
                "on" => Some(ReduceMotionMode::On),
                "off" => Some(ReduceMotionMode::Off),
                _ => None,
            }),
            remote: RemoteSettingsContent::default(),
            repl: None,
            server_url: None,
            session: None,
            status_bar: self.status_bar_settings_content(),
            tab_bar: self.tab_bar_settings_content(),
            tab_switcher: None,
            tabs: self.item_settings_content(),
            telemetry: self.telemetry_settings_content(),
            terminal: self.terminal_settings_content(),
            theme: Box::new(self.theme_settings_content()),
            title_bar: None,
            vim: None,
            vim_mode: None,
            workspace: self.workspace_settings_content(),
            which_key: None,
            modeline_lines: None,
            feature_flags: None,
            instrumentation: None,
        }
    }

    fn agent_settings_content(&self) -> Option<AgentSettingsContent> {
        let enabled = self.read_bool("chat.agent.enabled");
        skip_default(AgentSettingsContent {
            enabled: enabled,
            button: enabled,
            ..Default::default()
        })
    }

    fn editor_settings_content(&self) -> EditorSettingsContent {
        EditorSettingsContent {
            auto_signature_help: self.read_bool("editor.parameterHints.enabled"),
            language_detection: self.read_bool("workbench.editor.languageDetection"),
            autoscroll_on_clicks: None,
            cursor_blink: self.read_enum("editor.cursorBlinking", |s| match s {
                "blink" | "phase" | "expand" | "smooth" => Some(true),
                "solid" => Some(false),
                _ => None,
            }),
            cursor_shape: self.read_enum("editor.cursorStyle", |s| match s {
                "block" => Some(CursorShape::Block),
                "block-outline" => Some(CursorShape::Hollow),
                "line" | "line-thin" => Some(CursorShape::Bar),
                "underline" | "underline-thin" => Some(CursorShape::Underline),
                _ => None,
            }),
            cursor_animation: None,
            current_line_highlight: self.read_enum("editor.renderLineHighlight", |s| match s {
                "gutter" => Some(CurrentLineHighlight::Gutter),
                "line" => Some(CurrentLineHighlight::Line),
                "all" => Some(CurrentLineHighlight::All),
                _ => None,
            }),
            diagnostics_max_severity: None,
            double_click_in_multibuffer: None,
            drag_and_drop_selection: None,
            excerpt_context_lines: None,
            expand_excerpt_lines: None,
            fast_scroll_sensitivity: self.read_f32("editor.fastScrollSensitivity"),
            sticky_scroll: self.sticky_scroll_content(),
            go_to_definition_fallback: None,
            go_to_definition_scroll_strategy: None,
            lsp_results_location: None,
            gutter: self.gutter_content(),
            horizontal_scroll_margin: None,
            hover_popover_delay: self.read_u64("editor.hover.delay").map(Into::into),
            hover_popover_enabled: self.read_bool("editor.hover.enabled"),
            hover_popover_sticky: self.read_bool("editor.hover.sticky"),
            hover_popover_hiding_delay: self.read_u64("editor.hover.hidingDelay").map(Into::into),
            inline_code_actions: None,
            code_lens: None,
            jupyter: None,
            lsp_document_colors: None,
            lsp_document_links: self.read_bool("editor.links"),
            lsp_highlight_debounce: None,
            middle_click_paste: None,
            minimap: self.minimap_content(),
            minimum_contrast_for_highlights: None,
            multi_cursor_modifier: self.read_enum("editor.multiCursorModifier", |s| match s {
                "ctrlCmd" => Some(MultiCursorModifier::CmdOrCtrl),
                "alt" => Some(MultiCursorModifier::Alt),
                _ => None,
            }),
            redact_private_values: None,
            relative_line_numbers: self.read_enum("editor.lineNumbers", |s| match s {
                "relative" => Some(RelativeLineNumbers::Enabled),
                _ => None,
            }),
            rounded_selection: self.read_bool("editor.roundedSelection"),
            scroll_beyond_last_line: None,
            mouse_wheel_zoom: self.read_bool("editor.mouseWheelZoom"),
            scroll_sensitivity: self.read_f32("editor.mouseWheelScrollSensitivity"),
            scrollbar: self.scrollbar_content(),
            search: self.search_content(),
            search_wrap: None,
            seed_search_query_from_cursor: self.read_enum(
                "editor.find.seedSearchStringFromSelection",
                |s| match s {
                    "always" => Some(SeedQuerySetting::Always),
                    "selection" => Some(SeedQuerySetting::Selection),
                    "never" => Some(SeedQuerySetting::Never),
                    _ => None,
                },
            ),
            selection_highlight: self.read_bool("editor.selectionHighlight"),
            show_signature_help_after_edits: self.read_bool("editor.parameterHints.enabled"),
            snippet_sort_order: None,
            toolbar: None,
            use_smartcase_search: self.read_bool("search.smartCase"),
            vertical_scroll_margin: self.read_f32("editor.cursorSurroundingLines"),
            completion_menu_scrollbar: None,
            completion_detail_alignment: None,
            completion_menu_item_kind: None,
            diff_view_style: None,
            minimum_split_diff_width: None,
        }
    }

    fn sticky_scroll_content(&self) -> Option<StickyScrollContent> {
        skip_default(StickyScrollContent {
            enabled: self.read_bool("editor.stickyScroll.enabled"),
        })
    }

    fn gutter_content(&self) -> Option<GutterContent> {
        skip_default(GutterContent {
            line_numbers: self.read_enum("editor.lineNumbers", |s| match s {
                "on" | "relative" => Some(true),
                "off" => Some(false),
                _ => None,
            }),
            min_line_number_digits: None,
            runnables: None,
            breakpoints: None,
            bookmarks: None,
            folds: self.read_enum("editor.showFoldingControls", |s| match s {
                "always" | "mouseover" => Some(true),
                "never" => Some(false),
                _ => None,
            }),
            git_gutter_width: None,
        })
    }

    fn scrollbar_content(&self) -> Option<ScrollbarContent> {
        let scrollbar_axes = skip_default(ScrollbarAxesContent {
            horizontal: self.read_enum("editor.scrollbar.horizontal", |s| match s {
                "auto" | "visible" => Some(true),
                "hidden" => Some(false),
                _ => None,
            }),
            vertical: self.read_enum("editor.scrollbar.vertical", |s| match s {
                "auto" | "visible" => Some(true),
                "hidden" => Some(false),
                _ => None,
            }),
        })?;

        Some(ScrollbarContent {
            axes: Some(scrollbar_axes),
            ..Default::default()
        })
    }

    fn search_content(&self) -> Option<SearchSettingsContent> {
        skip_default(SearchSettingsContent {
            include_ignored: self.read_bool("search.useIgnoreFiles"),
            search_on_type: self.read_bool("search.searchOnType"),
            ..Default::default()
        })
    }

    fn semantic_token_rules(&self) -> Option<SemanticTokenRules> {
        let customizations = self
            .read_value("editor.semanticTokenColorCustomizations")?
            .as_object()?;

        skip_default(SemanticTokenRules {
            rules: customizations
                .get("rules")
                .and_then(|v| {
                    Some(
                        v.as_object()?
                            .iter()
                            .filter_map(|(k, v)| {
                                let v = v.as_object()?;

                                let mut underline = v
                                    .get("underline")
                                    .and_then(|b| b.as_bool())
                                    .unwrap_or(false);
                                let strikethrough = v
                                    .get("strikethrough")
                                    .and_then(|b| b.as_bool())
                                    .unwrap_or(false);
                                let mut font_weight =
                                    v.get("bold").and_then(|b| b.as_bool()).map(|b| {
                                        if b {
                                            SemanticTokenFontWeight::Bold
                                        } else {
                                            SemanticTokenFontWeight::Normal
                                        }
                                    });
                                let mut font_style =
                                    v.get("italic").and_then(|b| b.as_bool()).map(|b| {
                                        if b {
                                            SemanticTokenFontStyle::Italic
                                        } else {
                                            SemanticTokenFontStyle::Normal
                                        }
                                    });

                                match v.get("fontStyle").and_then(|s| s.as_str()).unwrap_or("") {
                                    "bold" => {
                                        font_style = Some(SemanticTokenFontStyle::Normal);
                                        font_weight = Some(SemanticTokenFontWeight::Bold);
                                    }
                                    "italic" => {
                                        font_style = Some(SemanticTokenFontStyle::Italic);
                                        font_weight = Some(SemanticTokenFontWeight::Normal);
                                    }
                                    "underline" => {
                                        underline = true;
                                    }
                                    "bold italic" | "italic bold" => {
                                        font_style = Some(SemanticTokenFontStyle::Italic);
                                        font_weight = Some(SemanticTokenFontWeight::Bold);
                                    }
                                    "normal" => {
                                        font_style = Some(SemanticTokenFontStyle::Normal);
                                        font_weight = Some(SemanticTokenFontWeight::Normal);
                                    }
                                    _ => {}
                                }

                                let foreground = v
                                    .get("foreground")
                                    .and_then(|v| Rgba::try_from(v.as_str()?).ok())
                                    .map(|s| s.to_owned());
                                let background = v
                                    .get("background")
                                    .and_then(|v| Rgba::try_from(v.as_str()?).ok())
                                    .map(|s| s.to_owned());

                                Some(SemanticTokenRule {
                                    token_type: Some(k.clone()),
                                    token_modifiers: vec![],
                                    style: vec![],
                                    underline: if underline {
                                        Some(SemanticTokenColorOverride::InheritForeground(true))
                                    } else {
                                        None
                                    },
                                    strikethrough: if strikethrough {
                                        Some(SemanticTokenColorOverride::InheritForeground(true))
                                    } else {
                                        None
                                    },
                                    foreground_color: foreground,
                                    background_color: background,
                                    font_weight,
                                    font_style,
                                })
                            })
                            .collect(),
                    )
                })
                .unwrap_or_default(),
        })
    }

    fn minimap_content(&self) -> Option<MinimapContent> {
        let minimap_enabled = self.read_bool("editor.minimap.enabled").unwrap_or(true);
        let autohide = self.read_bool("editor.minimap.autohide").unwrap_or(false);
        let show = match (minimap_enabled, autohide) {
            (true, false) => Some(ShowMinimap::Always),
            (true, true) => Some(ShowMinimap::Auto),
            (false, _) => Some(ShowMinimap::Never),
        };

        skip_default(MinimapContent {
            show,
            thumb: self.read_enum("editor.minimap.showSlider", |s| match s {
                "always" => Some(MinimapThumb::Always),
                "mouseover" => Some(MinimapThumb::Hover),
                _ => None,
            }),
            max_width_columns: self
                .read_u32("editor.minimap.maxColumn")
                .and_then(|v| NonZeroU32::new(v)),
            ..Default::default()
        })
    }

    fn git_panel_settings_content(&self) -> Option<GitPanelSettingsContent> {
        skip_default(GitPanelSettingsContent {
            button: self.read_bool("git.enabled"),
            fallback_branch_name: self.read_string("git.defaultBranchName"),
            ..Default::default()
        })
    }

    fn project_settings_content(&self) -> ProjectSettingsContent {
        ProjectSettingsContent {
            all_languages: AllLanguageSettingsContent {
                edit_predictions: self.edit_predictions_settings_content(),
                defaults: self.default_language_settings_content(),
                languages: Default::default(),
                file_types: self.file_types(),
            },
            worktree: self.worktree_settings_content(),
            lsp: Default::default(),
            terminal: None,
            dap: Default::default(),
            context_servers: self.context_servers(),
            context_server_timeout: None,
            load_direnv: None,
            git_hosting_providers: None,
            disable_ai: None,
        }
    }

    fn default_language_settings_content(&self) -> LanguageSettingsContent {
        LanguageSettingsContent {
            allow_rewrap: None,
            soft_wrap_indent: self.read_enum("editor.wrappingIndent", |s| match s {
                "none" => Some(SoftWrapIndent::None),
                "same" => Some(SoftWrapIndent::Same),
                "indent" => Some(SoftWrapIndent::ExtraOne),
                "deepIndent" => Some(SoftWrapIndent::ExtraTwo),
                _ => None,
            }),
            always_treat_brackets_as_autoclosed: None,
            auto_indent: None,
            auto_indent_on_paste: self.read_bool("editor.formatOnPaste"),
            code_actions_on_format: None,
            completions: skip_default(CompletionSettingsContent {
                words: self.read_bool("editor.suggest.showWords").map(|b| {
                    if b {
                        WordsCompletionMode::Enabled
                    } else {
                        WordsCompletionMode::Disabled
                    }
                }),
                ..Default::default()
            }),
            debuggers: None,
            edit_predictions_disabled_in: None,
            enable_language_server: None,
            ensure_final_newline_on_save: self.read_bool("files.insertFinalNewline"),
            line_ending: self.read_enum("files.eol", |s| match s {
                "\n" => Some(LineEndingSetting::PreferLf),
                "\r\n" => Some(LineEndingSetting::PreferCrlf),
                "auto" => Some(LineEndingSetting::Detect),
                _ => None,
            }),
            extend_comment_on_newline: None,
            extend_list_on_newline: None,
            indent_list_on_tab: None,
            // In VS Code, `editor.formatOnSaveMode` only applies when `editor.formatOnSave` is enabled.
            format_on_save: self.read_bool("editor.formatOnSave").map(|enabled| {
                if enabled {
                    self.read_enum("editor.formatOnSaveMode", |s| match s {
                        "modificationsIfAvailable" => Some(FormatOnSave::ModificationsIfAvailable),
                        "modifications" => Some(FormatOnSave::Modifications),
                        _ => None,
                    })
                    .unwrap_or(FormatOnSave::On)
                } else {
                    FormatOnSave::Off
                }
            }),
            formatter: None,
            hard_tabs: self.read_bool("editor.insertSpaces").map(|v| !v),
            indent_guides: skip_default(IndentGuideSettingsContent {
                enabled: self.read_bool("editor.guides.indentation"),
                ..Default::default()
            }),
            inlay_hints: None,
            jsx_tag_auto_close: None,
            language_servers: None,
            semantic_tokens: self
                .read_bool("editor.semanticHighlighting.enabled")
                .map(|enabled| {
                    if enabled {
                        SemanticTokens::Full
                    } else {
                        SemanticTokens::Off
                    }
                }),
            document_folding_ranges: None,
            document_symbols: None,
            linked_edits: self.read_bool("editor.linkedEditing"),
            preferred_line_length: self.read_u32("editor.wordWrapColumn"),
            prettier: None,
            remove_trailing_whitespace_on_save: self.read_bool("editor.trimAutoWhitespace"),
            show_completion_documentation: None,
            colorize_brackets: self.read_bool("editor.bracketPairColorization.enabled"),
            show_completions_on_input: self.read_bool("editor.suggestOnTriggerCharacters"),
            show_edit_predictions: self.read_bool("editor.inlineSuggest.enabled"),
            show_whitespaces: self.read_enum("editor.renderWhitespace", |s| {
                Some(match s {
                    "boundary" => ShowWhitespaceSetting::Boundary,
                    "trailing" => ShowWhitespaceSetting::Trailing,
                    "selection" => ShowWhitespaceSetting::Selection,
                    "all" => ShowWhitespaceSetting::All,
                    _ => ShowWhitespaceSetting::None,
                })
            }),
            show_wrap_guides: None,
            soft_wrap: self.read_enum("editor.wordWrap", |s| match s {
                "on" => Some(SoftWrap::EditorWidth),
                "wordWrapColumn" => Some(SoftWrap::PreferLine),
                "bounded" => Some(SoftWrap::Bounded),
                "off" => Some(SoftWrap::None),
                _ => None,
            }),
            tab_size: self
                .read_u32("editor.tabSize")
                .and_then(|n| NonZeroU32::new(n)),
            tasks: None,
            use_auto_surround: self.read_enum("editor.autoSurround", |s| match s {
                "languageDefined" | "quotes" | "brackets" => Some(true),
                "never" => Some(false),
                _ => None,
            }),
            use_autoclose: None,
            use_on_type_format: self.read_bool("editor.formatOnType"),
            whitespace_map: None,
            wrap_guides: self
                .read_value("editor.rulers")
                .and_then(|v| v.as_array())
                .map(|v| {
                    v.iter()
                        .flat_map(|n| n.as_u64().map(|n| n as usize))
                        .collect()
                }),
            word_diff_enabled: None,
        }
    }

    fn file_types(&self) -> Option<FileTypeMap> {
        // vscodes file association map is inverted from ours, so we flip the mapping before merging
        let mut associations: HashMap<Arc<str>, ExtendingSet<String>> = HashMap::default();
        let map = self.read_value("files.associations")?.as_object()?;
        for (k, v) in map {
            let Some(v) = v.as_str() else { continue };
            associations
                .entry(v.into())
                .or_default()
                .0
                .insert(k.clone());
        }
        skip_default(FileTypeMap(associations))
    }

    fn edit_predictions_settings_content(&self) -> Option<EditPredictionSettingsContent> {
        let mut disabled_globs = self
            .read_value("cursor.general.globalCursorIgnoreList")?
            .as_array()?
            .iter()
            .filter_map(Value::as_str)
            .filter(|glob| !glob.is_empty() && *glob != SplicingVec::REST)
            .map(str::to_owned)
            .collect::<Vec<_>>();
        if disabled_globs.is_empty() {
            return None;
        }
        disabled_globs.push(SplicingVec::REST.to_owned());

        Some(EditPredictionSettingsContent {
            disabled_globs: Some(SplicingVec::from(disabled_globs)),
            ..EditPredictionSettingsContent::default()
        })
    }

    fn outline_panel_settings_content(&self) -> Option<OutlinePanelSettingsContent> {
        skip_default(OutlinePanelSettingsContent {
            file_icons: self.read_bool("outline.icons"),
            folder_indicator: self.read_bool("outline.icons").map(|icons| {
                if icons {
                    FolderIndicator::Icon
                } else {
                    FolderIndicator::Chevron
                }
            }),
            git_status: self.read_bool("git.decorations.enabled"),
            ..Default::default()
        })
    }

    fn node_binary_settings(&self) -> Option<NodeBinarySettings> {
        // this just sets the binary name instead of a full path so it relies on path lookup
        // resolving to the one you want
        skip_default(NodeBinarySettings {
            npm_path: self.read_enum("npm.packageManager", |s| match s {
                v @ ("npm" | "yarn" | "bun" | "pnpm") => Some(v.to_owned()),
                _ => None,
            }),
            ..Default::default()
        })
    }

    fn git_settings_content(&self) -> Option<GitSettings> {
        let inline_blame = self.read_bool("git.blame.editorDecoration.enabled")?;
        skip_default(GitSettings {
            inline_blame: Some(InlineBlameSettings {
                enabled: Some(inline_blame),
                ..Default::default()
            }),
            ..Default::default()
        })
    }

    fn context_servers(&self) -> HashMap<Arc<str>, ContextServerSettingsContent> {
        #[derive(Deserialize)]
        struct VsCodeContextServerCommand {
            command: PathBuf,
            args: Option<Vec<String>>,
            env: Option<HashMap<String, String>>,
            // note: we don't support envFile and type
        }
        let Some(mcp) = self.read_value("mcp").and_then(|v| v.as_object()) else {
            return Default::default();
        };
        mcp.iter()
            .filter_map(|(k, v)| {
                Some((
                    k.clone().into(),
                    ContextServerSettingsContent::Stdio {
                        enabled: true,
                        remote: false,
                        command: serde_json::from_value::<VsCodeContextServerCommand>(v.clone())
                            .ok()
                            .map(|cmd| ContextServerCommand {
                                path: cmd.command,
                                args: cmd.args.unwrap_or_default(),
                                env: cmd.env,
                                timeout: None,
                            })?,
                    },
                ))
            })
            .collect()
    }

    fn item_settings_content(&self) -> Option<ItemSettingsContent> {
        skip_default(ItemSettingsContent {
            git_status: self.read_bool("git.decorations.enabled"),
            close_position: self.read_enum("workbench.editor.tabActionLocation", |s| match s {
                "right" => Some(ClosePosition::Right),
                "left" => Some(ClosePosition::Left),
                _ => None,
            }),
            file_icons: self.read_bool("workbench.editor.showIcons"),
            activate_on_close: self
                .read_bool("workbench.editor.focusRecentEditorAfterClose")
                .map(|b| {
                    if b {
                        ActivateOnClose::History
                    } else {
                        ActivateOnClose::LeftNeighbour
                    }
                }),
            show_diagnostics: None,
            show_close_button: self
                .read_bool("workbench.editor.tabActionCloseVisibility")
                .map(|b| {
                    if b {
                        ShowCloseButton::Always
                    } else {
                        ShowCloseButton::Hidden
                    }
                }),
        })
    }

    fn preview_tabs_settings_content(&self) -> Option<PreviewTabsSettingsContent> {
        skip_default(PreviewTabsSettingsContent {
            enabled: self.read_bool("workbench.editor.enablePreview"),
            enable_preview_from_project_panel: None,
            enable_preview_from_file_finder: self
                .read_bool("workbench.editor.enablePreviewFromQuickOpen"),
            enable_preview_from_multibuffer: None,
            enable_preview_multibuffer_from_code_navigation: None,
            enable_preview_file_from_code_navigation: None,
            enable_keep_preview_on_code_navigation: self
                .read_bool("workbench.editor.enablePreviewFromCodeNavigation"),
        })
    }

    fn tab_bar_settings_content(&self) -> Option<TabBarSettingsContent> {
        skip_default(TabBarSettingsContent {
            show: self.read_enum("workbench.editor.showTabs", |s| match s {
                "multiple" => Some(true),
                "single" | "none" => Some(false),
                _ => None,
            }),
            show_nav_history_buttons: None,
            show_tab_bar_buttons: self
                .read_str("workbench.editor.editorActionsLocation")
                .and_then(|str| if str == "hidden" { Some(false) } else { None }),
            show_pinned_tabs_in_separate_row: None,
        })
    }

    fn status_bar_settings_content(&self) -> Option<StatusBarSettingsContent> {
        skip_default(StatusBarSettingsContent {
            show: self.read_bool("workbench.statusBar.visible"),
            show_active_file: None,
            active_language_button: None,
            cursor_position_button: None,
            line_endings_button: None,
            active_encoding_button: None,
            pending_keystrokes_indicator: None,
        })
    }

    fn project_panel_settings_content(&self) -> Option<ProjectPanelSettingsContent> {
        let mut project_panel_settings = ProjectPanelSettingsContent {
            auto_fold_dirs: self.read_bool("explorer.compactFolders"),
            auto_reveal_entries: self.read_bool("explorer.autoReveal"),
            bold_folder_labels: None,
            button: None,
            title_tooltip_delay: None,
            default_width: None,
            dock: None,
            drag_and_drop: None,
            entry_spacing: None,
            file_icons: None,
            folder_indicator: None,
            git_status: self.read_bool("git.decorations.enabled"),
            hide_gitignore: self.read_bool("explorer.excludeGitIgnore"),
            hide_hidden: None,
            hide_root: None,
            indent_guides: None,
            indent_size: None,
            scrollbar: self.read_bool("workbench.list.horizontalScrolling").map(
                |horizontal_scrolling| ProjectPanelScrollbarSettingsContent {
                    show: None,
                    horizontal_scroll: Some(horizontal_scrolling),
                },
            ),
            show_diagnostics: self
                .read_bool("problems.decorations.enabled")
                .and_then(|b| if b { Some(ShowDiagnostics::Off) } else { None }),
            sort_mode: self.read_enum("explorer.sortOrder", |s| match s {
                "default" | "foldersNestsFiles" => Some(ProjectPanelSortMode::DirectoriesFirst),
                "mixed" => Some(ProjectPanelSortMode::Mixed),
                "filesFirst" => Some(ProjectPanelSortMode::FilesFirst),
                _ => None,
            }),
            sort_order: self.read_enum("explorer.sortOrderLexicographicOptions", |s| match s {
                "default" => Some(ProjectPanelSortOrder::Default),
                "upper" => Some(ProjectPanelSortOrder::Upper),
                "lower" => Some(ProjectPanelSortOrder::Lower),
                "unicode" => Some(ProjectPanelSortOrder::Unicode),
                _ => None,
            }),
            starts_open: None,
            sticky_scroll: None,
            auto_open: None,
            diagnostic_badges: None,
            git_status_indicator: None,
        };

        if let (Some(false), Some(false)) = (
            self.read_bool("explorer.decorations.badges"),
            self.read_bool("explorer.decorations.colors"),
        ) {
            project_panel_settings.git_status = Some(false);
            project_panel_settings.show_diagnostics = Some(ShowDiagnostics::Off);
        }

        skip_default(project_panel_settings)
    }

    fn telemetry_settings_content(&self) -> Option<TelemetrySettingsContent> {
        self.read_enum("telemetry.telemetryLevel", |level| {
            let (metrics, diagnostics) = match level {
                "all" => (true, true),
                "error" | "crash" => (false, true),
                "off" => (false, false),
                _ => return None,
            };
            Some(TelemetrySettingsContent {
                metrics: Some(metrics),
                diagnostics: Some(diagnostics),
                anthropic_retention: None,
            })
        })
    }

    fn terminal_settings_content(&self) -> Option<TerminalSettingsContent> {
        let (font_family, font_fallbacks) = self.read_fonts("terminal.integrated.fontFamily");
        skip_default(TerminalSettingsContent {
            alternate_scroll: None,
            blinking: self
                .read_bool("terminal.integrated.cursorBlinking")
                .map(|b| {
                    if b {
                        TerminalBlink::On
                    } else {
                        TerminalBlink::Off
                    }
                }),
            button: None,
            copy_on_select: self.read_bool("terminal.integrated.copyOnSelection"),
            cursor_shape: self.read_enum("terminal.integrated.cursorStyle", |s| match s {
                "block" => Some(CursorShapeContent::Block),
                "line" => Some(CursorShapeContent::Bar),
                "underline" => Some(CursorShapeContent::Underline),
                _ => None,
            }),
            default_height: None,
            default_width: None,
            dock: None,
            starts_open: None,
            font_fallbacks,
            font_family,
            font_features: None,
            font_size: self
                .read_f32("terminal.integrated.fontSize")
                .map(FontSize::from),
            font_weight: None,
            keep_selection_on_copy: None,
            open_links_in_mouse_mode: None,
            line_height: self
                .read_f32("terminal.integrated.lineHeight")
                .map(|lh| TerminalLineHeight::Custom(lh)),
            max_scroll_history_lines: self.read_usize("terminal.integrated.scrollback"),
            bell: self
                .read_value("accessibility.signals.terminalBell")
                .and_then(|v| Some(v.get("sound")?.as_str()? == "on"))
                .or_else(|| {
                    // Older deprecated setting, might as well still support it:
                    self.read_value("terminal.integrated.enableBell")
                        .map(|v| v.as_bool() == Some(true) || v.as_str() == Some("both"))
                })
                .map(|enabled| {
                    if enabled {
                        TerminalBell::System
                    } else {
                        TerminalBell::Off
                    }
                }),
            minimum_contrast: None,
            option_as_meta: self.read_bool("terminal.integrated.macOptionIsMeta"),
            project: self.project_terminal_settings_content(),
            scrollbar: None,
            scroll_multiplier: None,
            toolbar: None,
            show_count_badge: None,
            flexible: None,
        })
    }

    fn project_terminal_settings_content(&self) -> ProjectTerminalSettingsContent {
        #[cfg(target_os = "windows")]
        let platform = "windows";
        #[cfg(target_os = "linux")]
        let platform = "linux";
        #[cfg(target_os = "macos")]
        let platform = "osx";
        #[cfg(target_os = "freebsd")]
        let platform = "freebsd";
        let env = self
            .read_value(&format!("terminal.integrated.env.{platform}"))
            .and_then(|v| v.as_object())
            .map(|v| {
                v.iter()
                    .map(|(k, v)| (k.clone(), v.to_string()))
                    // zed does not support substitutions, so this can break env vars
                    .filter(|(_, v)| !v.contains('$'))
                    .collect()
            });

        ProjectTerminalSettingsContent {
            // TODO: handle arguments
            shell: self
                .read_string(&format!("terminal.integrated.{platform}Exec"))
                .map(|s| Shell::Program(s)),
            working_directory: None,
            env,
            detect_venv: None,
            path_hyperlink_regexes: None,
            path_hyperlink_timeout_ms: None,
        }
    }

    fn theme_settings_content(&self) -> ThemeSettingsContent {
        let (buffer_font_family, buffer_font_fallbacks) = self.read_fonts("editor.fontFamily");
        ThemeSettingsContent {
            ui_font_size: None,
            ui_font_family: None,
            ui_font_fallbacks: None,
            ui_font_features: None,
            ui_font_weight: None,
            buffer_font_family,
            buffer_font_fallbacks,
            buffer_font_size: self.read_f32("editor.fontSize").map(FontSize::from),
            buffer_font_weight: self.read_f32("editor.fontWeight").map(FontWeightContent),
            buffer_line_height: None,
            buffer_font_features: None,
            agent_ui_font_family: None,
            agent_ui_font_size: None,
            agent_buffer_font_family: None,
            agent_buffer_font_size: None,
            git_commit_buffer_font_size: None,
            mermaid_font_family: None,
            theme: None,
            icon_theme: None,
            ui_density: None,
            unnecessary_code_fade: None,
            experimental_theme_overrides: None,
            theme_overrides: Default::default(),
        }
    }

    fn workspace_settings_content(&self) -> WorkspaceSettingsContent {
        WorkspaceSettingsContent {
            active_pane_modifiers: self.active_pane_modifiers(),
            accessible_mode: None,
            text_rendering_mode: None,
            use_display_p3: None,
            autosave: self.read_enum("files.autoSave", |s| match s {
                "off" => Some(AutosaveSetting::Off),
                "afterDelay" => Some(AutosaveSetting::AfterDelay {
                    milliseconds: self
                        .read_value("files.autoSaveDelay")
                        .and_then(|v| v.as_u64())
                        .unwrap_or(1000)
                        .into(),
                }),
                "onFocusChange" => Some(AutosaveSetting::OnFocusChange),
                "onWindowChange" => Some(AutosaveSetting::OnWindowChange),
                _ => None,
            }),
            bottom_dock_layout: None,
            centered_layout: None,
            cli_default_open_behavior: None,
            default_open_behavior: None,
            close_on_file_delete: None,
            close_panel_on_toggle: None,
            command_aliases: Default::default(),
            confirm_quit: self.read_enum("window.confirmBeforeClose", |s| match s {
                "always" | "keyboardOnly" => Some(true),
                "never" => Some(false),
                _ => None,
            }),
            drop_target_size: None,
            // workbench.editor.limit contains "enabled", "value", and "perEditorGroup"
            // our semantics match if those are set to true, some N, and true respectively.
            // we'll ignore "perEditorGroup" for now since we only support a global max
            max_tabs: if self.read_bool("workbench.editor.limit.enabled") == Some(true) {
                self.read_usize("workbench.editor.limit.value")
                    .and_then(|n| NonZeroUsize::new(n))
            } else {
                None
            },
            on_new_window: None,
            on_last_window_closed: None,
            pane_split_direction_horizontal: None,
            pane_split_direction_vertical: None,
            resize_all_panels_in_dock: None,
            restore_on_file_reopen: self.read_bool("workbench.editor.restoreViewState"),
            reveal_if_open: self.read_bool("workbench.editor.revealIfOpen"),
            restore_on_startup: None,
            window_decorations: None,
            show_call_status_icon: None,
            use_system_path_prompts: self.read_bool("files.simpleDialog.enable").map(|b| !b),
            use_system_prompts: None,
            use_system_window_tabs: self.read_bool("window.nativeTabs"),
            fullscreen_mode: self.read_bool("window.nativeFullScreen").map(|b| {
                if b {
                    FullscreenMode::Native
                } else {
                    FullscreenMode::Simple
                }
            }),
            window_title_format: self.read_window_title_format(),
            window_title_separator: self.read_string("window.titleSeparator"),
            when_closing_with_no_tabs: self.read_bool("window.closeWhenEmpty").map(|b| {
                if b {
                    CloseWindowWhenNoItems::CloseWindow
                } else {
                    CloseWindowWhenNoItems::KeepWindowOpen
                }
            }),
            zoomed_padding: None,
            focus_follows_mouse: None,
        }
    }

    fn active_pane_modifiers(&self) -> Option<ActivePaneModifiers> {
        if self.read_bool("accessibility.dimUnfocused.enabled") == Some(true)
            && let Some(opacity) = self.read_f32("accessibility.dimUnfocused.opacity")
        {
            Some(ActivePaneModifiers {
                border_size: None,
                inactive_opacity: Some(InactiveOpacity(opacity)),
            })
        } else {
            None
        }
    }

    fn worktree_settings_content(&self) -> WorktreeSettingsContent {
        WorktreeSettingsContent {
            prevent_sharing_in_public_channels: false,
            file_scan_depth: None,
            file_scan_exclusions: Self::enabled_patterns(self.read_value("files.exclude")),
            // `files.watcherInclude` adds watch roots, not Git-ignore overrides
            file_scan_inclusions: None,
            scan_symlinks: None,
            private_files: None,
            hidden_files: None,
            // Zed cannot represent the writable exceptions in `files.readonlyExclude`
            read_only_files: Self::enabled_patterns(
                self.read_value("files.readonlyInclude").filter(|_| {
                    !self
                        .read_value("files.readonlyExclude")
                        .and_then(Value::as_object)
                        .is_some_and(|patterns| {
                            patterns
                                .values()
                                .any(|enabled| enabled.as_bool() == Some(true))
                        })
                }),
            ),
        }
    }

    fn enabled_patterns(value: Option<&Value>) -> Option<SplicingVec> {
        value
            .and_then(Value::as_object)
            .map(|patterns| {
                patterns
                    .iter()
                    .filter(|(pattern, enabled)| {
                        // Zed reserves `...` for inheritance, not a literal path
                        !pattern.is_empty()
                            && pattern.as_str() != SplicingVec::REST
                            && enabled.as_bool() == Some(true)
                    })
                    .map(|(pattern, _)| pattern.to_owned())
                    .collect::<Vec<_>>()
            })
            .filter(|patterns| !patterns.is_empty())
            .map(|mut patterns| {
                patterns.push(SplicingVec::REST.to_owned());
                SplicingVec::from(patterns)
            })
    }
}

fn translate_vscode_window_title_format(template: &str) -> String {
    let mut translated = String::new();
    let mut start = 0;

    // Workspace owns the runtime template parser, so the VS Code importer keeps
    // its own small placeholder scan here instead of depending on that crate.
    while let Some(offset) = template[start..].find("${") {
        let variable_start = start + offset;
        translated.push_str(&template[start..variable_start]);

        let content_start = variable_start + 2;
        let Some(content_end_offset) = template[content_start..].find('}') else {
            translated.push_str(&template[variable_start..]);
            return translated;
        };

        let content_end = content_start + content_end_offset;
        let variable = &template[content_start..content_end];
        match variable {
            "projectName" | "fileName" | "filePath" | "relativePath" | "fileStem"
            | "remoteHost" | "appName" | "branch" | "separator" => {
                translated.push_str(&template[variable_start..=content_end]);
            }
            // Keep VS Code alias support in the importer so native Zed settings
            // only expose the documented placeholder names.
            "rootName" => translated.push_str("${projectName}"),
            "activeEditorShort" => translated.push_str("${fileName}"),
            "activeEditorMedium" => translated.push_str("${relativePath}"),
            "activeEditorLong" => translated.push_str("${filePath}"),
            "activeRepositoryBranchName" => translated.push_str("${branch}"),
            // VS Code's `${remoteName}` is a provider label such as `SSH`, while
            // Zed's `${remoteName}` resolves to the connection's name or host,
            // so the token is dropped rather than imported with mismatched
            // semantics.
            _ => {}
        }

        start = content_end + 1;
    }

    translated.push_str(&template[start..]);
    translated
}

fn skip_default<T: Default + PartialEq>(value: T) -> Option<T> {
    if value == T::default() {
        None
    } else {
        Some(value)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::settings_content::merge_from::MergeFrom;

    fn imported_reduce_motion(content: &str) -> Option<ReduceMotionMode> {
        VsCodeSettings::from_str(content, VsCodeSettingsSource::VsCode)
            .unwrap()
            .settings_content()
            .reduce_motion
    }

    #[test]
    fn test_import_disabled_globs_extends_inherited_patterns() -> Result<()> {
        for (ignore_list, expected_imported, expected_merged) in [
            (
                serde_json::json!(["**/build/**", "**/cache/**"]),
                serde_json::json!(["**/build/**", "**/cache/**", "..."]),
                serde_json::json!(["**/build/**", "**/cache/**", "**/inherited/**"]),
            ),
            (
                serde_json::json!(["**/build/**", "", false, null, 1, {}, []]),
                serde_json::json!(["**/build/**", "..."]),
                serde_json::json!(["**/build/**", "**/inherited/**"]),
            ),
            (
                serde_json::json!(["...", "**/build/**", false]),
                serde_json::json!(["**/build/**", "..."]),
                serde_json::json!(["**/build/**", "**/inherited/**"]),
            ),
            (
                serde_json::json!(["**/inherited/**", "**/build/**"]),
                serde_json::json!(["**/inherited/**", "**/build/**", "..."]),
                serde_json::json!(["**/inherited/**", "**/build/**"]),
            ),
        ] {
            let content = serde_json::json!({
                "cursor.general.globalCursorIgnoreList": ignore_list,
            });
            let imported =
                VsCodeSettings::from_str(&content.to_string(), VsCodeSettingsSource::Cursor)?
                    .settings_content();
            let imported = imported
                .project
                .all_languages
                .edit_predictions
                .context("imported edit prediction settings")?;
            assert_eq!(
                serde_json::to_value(&imported.disabled_globs)?,
                expected_imported
            );

            let mut inherited = EditPredictionSettingsContent {
                disabled_globs: Some(SplicingVec::from(vec!["**/inherited/**".to_string()])),
                ..Default::default()
            };
            inherited.merge_from(&imported);
            assert_eq!(
                serde_json::to_value(&inherited.disabled_globs)?,
                expected_merged
            );
        }
        Ok(())
    }

    #[test]
    fn test_import_disabled_globs_omits_empty_results() -> Result<()> {
        let inherited = AllLanguageSettingsContent {
            edit_predictions: Some(EditPredictionSettingsContent {
                disabled_globs: Some(SplicingVec::from(vec!["**/inherited/**".to_string()])),
                ..Default::default()
            }),
            ..Default::default()
        };
        for content in [
            r#"{"cursor.general.globalCursorIgnoreList": "**/build/**"}"#,
            r#"{"cursor.general.globalCursorIgnoreList": ["..."]}"#,
            r#"{"cursor.general.globalCursorIgnoreList": [""]}"#,
            r#"{"cursor.general.globalCursorIgnoreList": ["...", "", false, null]}"#,
            r#"{"cursor.general.globalCursorIgnoreList": []}"#,
            r#"{"cursor.general.globalCursorIgnoreList": [false, null, 1, {}, []]}"#,
            r#"{"cursor.general.globalCursorIgnoreList": null}"#,
            r#"{}"#,
        ] {
            let imported =
                VsCodeSettings::from_str(content, VsCodeSettingsSource::Cursor)?.settings_content();
            assert_eq!(imported.project.all_languages.edit_predictions, None);
            let mut unchanged = inherited.clone();
            unchanged.merge_from(&imported.project.all_languages);
            assert_eq!(unchanged.edit_predictions, inherited.edit_predictions);
        }
        Ok(())
    }

    #[test]
    fn test_import_file_exclusions() -> Result<()> {
        let imported = VsCodeSettings::from_str(
            r#"{
                "files.exclude": {
                    "": true,
                    "**/array/**": [],
                    "**/build/**": true,
                    "**/cache/**": false,
                    "**/null/**": null,
                    "**/number/**": 1,
                    "**/object/**": {"enabled": true},
                    "**/string/**": "true",
                    "**/target/**": true,
                    "**/*.js": {"when": "$(basename).ts"},
                    "...": true
                }
            }"#,
            VsCodeSettingsSource::VsCode,
        )?
        .settings_content();
        assert_eq!(
            serde_json::to_value(&imported.project.worktree.file_scan_exclusions)?,
            serde_json::json!(["**/build/**", "**/target/**", "..."])
        );

        let mut inherited = WorktreeSettingsContent {
            file_scan_exclusions: Some(SplicingVec::from(vec!["**/inherited/**".to_string()])),
            ..Default::default()
        };
        inherited.merge_from(&imported.project.worktree);
        assert_eq!(
            serde_json::to_value(&inherited.file_scan_exclusions)?,
            serde_json::json!(["**/build/**", "**/target/**", "**/inherited/**"])
        );
        Ok(())
    }

    #[test]
    fn test_import_file_exclusions_without_usable_patterns() -> Result<()> {
        let inherited = WorktreeSettingsContent {
            file_scan_exclusions: Some(SplicingVec::from(vec!["**/inherited/**".to_string()])),
            ..Default::default()
        };
        for content in [
            r#"{"files.exclude": "**/cache/**"}"#,
            r#"{"files.exclude": 1}"#,
            r#"{"files.exclude": ["**/cache/**"]}"#,
            r#"{"files.exclude": []}"#,
            r#"{"files.exclude": null}"#,
            r#"{"files.exclude": true}"#,
            r#"{"files.exclude": {"": true}}"#,
            r#"{"files.exclude": {"**/cache/**": "true"}}"#,
            r#"{"files.exclude": {"**/cache/**": false}}"#,
            r#"{"files.exclude": {"**/*.js": {"when": "$(basename).ts"}}}"#,
            r#"{"files.exclude": {"...": true}}"#,
            r#"{"files.exclude": {}}"#,
            r#"{"files.watcherExclude": {"**/cache/**": true}}"#,
            r#"{}"#,
        ] {
            let imported =
                VsCodeSettings::from_str(content, VsCodeSettingsSource::VsCode)?.settings_content();
            assert_eq!(
                imported.project.worktree.file_scan_exclusions, None,
                "{content}"
            );
            let mut unchanged = inherited.clone();
            unchanged.merge_from(&imported.project.worktree);
            assert_eq!(
                unchanged.file_scan_exclusions, inherited.file_scan_exclusions,
                "{content}"
            );
        }
        Ok(())
    }

    #[test]
    fn test_import_watcher_include_preserves_file_scan_inclusions() -> Result<()> {
        let inherited = WorktreeSettingsContent {
            file_scan_inclusions: Some(SplicingVec::from(vec![
                ".env*".to_string(),
                "**/*.local".to_string(),
            ])),
            ..Default::default()
        };
        for content in [
            r#"{}"#,
            r#"{"files.watcherInclude": []}"#,
            r#"{"files.watcherInclude": ["linked-folder"]}"#,
            r#"{"files.watcherInclude": ["..."]}"#,
            r#"{"files.watcherInclude": ["linked-folder", false]}"#,
            r#"{"files.watcherInclude": {"linked-folder": true}}"#,
        ] {
            let mut content: Value = serde_json::from_str(content)?;
            content["editor.tabSize"] = serde_json::json!(8);
            let imported = VsCodeSettings::from_str(
                &serde_json::to_string(&content)?,
                VsCodeSettingsSource::VsCode,
            )?
            .settings_content();
            assert_eq!(imported.project.worktree.file_scan_inclusions, None);
            assert_eq!(
                imported.project.all_languages.defaults.tab_size,
                NonZeroU32::new(8)
            );

            let mut unchanged = inherited.clone();
            unchanged.merge_from(&imported.project.worktree);
            assert_eq!(
                unchanged.file_scan_inclusions,
                inherited.file_scan_inclusions
            );
        }
        Ok(())
    }

    #[test]
    fn test_import_read_only_files() -> Result<()> {
        let inherited = WorktreeSettingsContent {
            read_only_files: Some(SplicingVec::from(vec!["**/*.lock".to_string()])),
            ..Default::default()
        };
        let imported = VsCodeSettings::from_str(
            r#"{
                "files.readonlyInclude": {
                    "": true,
                    "**/*.gen.rs": true,
                    "**/*.lock": false,
                    "**/generated/**": true,
                    "...": true
                },
                "files.readonlyExclude": {"**/editable.gen.rs": false}
            }"#,
            VsCodeSettingsSource::VsCode,
        )?
        .worktree_settings_content();
        assert_eq!(
            serde_json::to_value(&imported.read_only_files)?,
            serde_json::json!(["**/*.gen.rs", "**/generated/**", "..."])
        );
        let mut spliced = inherited.clone();
        spliced.merge_from(&imported);
        assert_eq!(
            serde_json::to_value(&spliced.read_only_files)?,
            serde_json::json!(["**/*.gen.rs", "**/generated/**", "**/*.lock"])
        );

        for content in [
            r#"{"files.readonlyExclude": {"**/*.gen.rs": true}}"#,
            r#"{"files.readonlyInclude": {"**/*.gen.rs": false}}"#,
            r#"{"files.readonlyInclude": {"": true}}"#,
            r#"{"files.readonlyInclude": {"...": true}}"#,
            r#"{"files.readonlyInclude": ["**/*.gen.rs"]}"#,
            r#"{"files.readonlyInclude": {}}"#,
            "{}",
        ] {
            let imported = VsCodeSettings::from_str(content, VsCodeSettingsSource::VsCode)?
                .worktree_settings_content();
            assert_eq!(imported.read_only_files, None);
            let mut unchanged = inherited.clone();
            unchanged.merge_from(&imported);
            assert_eq!(unchanged.read_only_files, inherited.read_only_files);
        }
        Ok(())
    }

    #[test]
    fn test_import_read_only_files_with_exclusions() -> Result<()> {
        let imported = VsCodeSettings::from_str(
            r#"{
                "files.readonlyExclude": {"**/*.lock": true, "**/editable.gen.rs": true},
                "files.readonlyInclude": {"**/*.gen.rs": true},
                "editor.tabSize": 8
            }"#,
            VsCodeSettingsSource::VsCode,
        )?
        .settings_content();
        assert_eq!(imported.project.worktree.read_only_files, None);
        assert_eq!(
            imported.project.all_languages.defaults.tab_size,
            NonZeroU32::new(8)
        );
        let mut inherited = WorktreeSettingsContent {
            read_only_files: Some(SplicingVec::from(vec![String::from("**/*.lock")])),
            ..WorktreeSettingsContent::default()
        };
        inherited.merge_from(&imported.project.worktree);
        assert_eq!(
            serde_json::to_value(&inherited.read_only_files)?,
            serde_json::json!(["**/*.lock"])
        );
        Ok(())
    }

    #[test]
    fn test_import_reduce_motion() {
        assert_eq!(
            imported_reduce_motion(r#"{ "workbench.reduceMotion": "on" }"#),
            Some(ReduceMotionMode::On)
        );
        assert_eq!(
            imported_reduce_motion(r#"{ "workbench.reduceMotion": "off" }"#),
            Some(ReduceMotionMode::Off)
        );
        assert_eq!(
            imported_reduce_motion(r#"{ "workbench.reduceMotion": "auto" }"#),
            None
        );
        assert_eq!(imported_reduce_motion("{}"), None);
    }

    #[test]
    fn test_import_command_palette_history() {
        for (content, expected) in [
            (r#"{ "workbench.commandPalette.history": 0 }"#, Some(false)),
            (r#"{ "workbench.commandPalette.history": 1 }"#, Some(true)),
            (r#"{ "workbench.commandPalette.history": 50 }"#, Some(true)),
            ("{}", None),
        ] {
            let settings = VsCodeSettings::from_str(content, VsCodeSettingsSource::VsCode)
                .unwrap()
                .settings_content();
            assert_eq!(
                settings
                    .command_palette
                    .and_then(|settings| settings.use_command_history),
                expected,
            );
        }
    }

    #[test]
    fn test_import_reveal_if_open() {
        let settings = VsCodeSettings::from_str(
            r#"{ "workbench.editor.revealIfOpen": true }"#,
            VsCodeSettingsSource::VsCode,
        )
        .unwrap()
        .settings_content();

        assert_eq!(settings.workspace.reveal_if_open, Some(true));
    }

    #[test]
    fn test_import_window_title_format() {
        let imported_title = |content: &str| {
            VsCodeSettings::from_str(content, VsCodeSettingsSource::VsCode)
                .unwrap()
                .settings_content()
                .workspace
                .window_title_format
        };

        assert_eq!(imported_title("{}"), None);

        // VS Code variables are translated to their Zed equivalents.
        assert_eq!(
            imported_title(
                r#"{ "window.title": "${rootName} ${activeRepositoryBranchName} ${activeEditorMedium}" }"#,
            ),
            Some("${projectName} ${branch} ${relativePath}".to_string())
        );

        // Zed-native variables pass through unchanged.
        assert_eq!(
            imported_title(r#"{ "window.title": "${projectName}${separator}${filePath}" }"#),
            Some("${projectName}${separator}${filePath}".to_string())
        );

        // VS Code's `${remoteName}` is a provider label such as `SSH`, which
        // doesn't match Zed's connection-name semantics, so it is dropped.
        assert_eq!(
            imported_title(r#"{ "window.title": "${remoteName}: ${rootName}" }"#),
            Some(": ${projectName}".to_string())
        );

        // Templates that translate to nothing but whitespace fall back to
        // Zed's default title instead of overriding it.
        assert_eq!(
            imported_title(r#"{ "window.title": " ${activeFolderShort} " }"#),
            None
        );

        // Literal text around unsupported variables is still imported.
        assert_eq!(
            imported_title(r#"{ "window.title": "${activeFolderShort} — literal" }"#),
            Some(" — literal".to_string())
        );
    }

    fn imported_soft_wrap_indent(content: &str) -> Option<SoftWrapIndent> {
        VsCodeSettings::from_str(content, VsCodeSettingsSource::VsCode)
            .unwrap()
            .settings_content()
            .project
            .all_languages
            .defaults
            .soft_wrap_indent
    }

    #[test]
    fn test_import_wrapping_indent() {
        assert_eq!(
            imported_soft_wrap_indent(r#"{ "editor.wrappingIndent": "none" }"#),
            Some(SoftWrapIndent::None)
        );
        assert_eq!(
            imported_soft_wrap_indent(r#"{ "editor.wrappingIndent": "same" }"#),
            Some(SoftWrapIndent::Same)
        );
        assert_eq!(
            imported_soft_wrap_indent(r#"{ "editor.wrappingIndent": "indent" }"#),
            Some(SoftWrapIndent::ExtraOne)
        );
        assert_eq!(
            imported_soft_wrap_indent(r#"{ "editor.wrappingIndent": "deepIndent" }"#),
            Some(SoftWrapIndent::ExtraTwo)
        );
        assert_eq!(
            imported_soft_wrap_indent(r#"{ "editor.wrappingIndent": "invalid" }"#),
            None
        );
        assert_eq!(imported_soft_wrap_indent("{}"), None);
    }
}