Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

43.2 KB
Raw Blame
use ide_core::settings::Settings;
use ide_core::{IdeError, IdeResult, project_dir};
use parking_lot::RwLock;
use serde_json::Value as Json;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use toml_edit::{DocumentMut, Item, Table, TableLike};

/// Layered settings: defaults → `<app-config>/settings.toml` → `<project>/.openidea/settings.toml`.
/// Writes go through `toml_edit` so user comments survive.
///
/// TOML keys use the camelCase names of the serde [`Settings`] struct, e.g.
/// `[editor]` / `fontSize = 14`. A layer that fails to parse or holds values of
/// the wrong type is logged and ignored as a whole.
const PROJECT_FILE: &str = "settings.toml";

pub struct SettingsStore {
    global_file: PathBuf,
    project_file: Option<PathBuf>,
    effective: RwLock<Settings>,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub enum SettingsScope {
    Global,
    Project,
}

fn remove_global_settings(layer: &mut Json) {
    if let Some(layer) = layer.as_object_mut() {
        layer.remove("mcpServer");
    }
    if let Some(editor) = layer.get_mut("editor").and_then(Json::as_object_mut) {
        editor.remove("customSchemes");
    }
}

fn defaults_json() -> Json {
    serde_json::to_value(Settings::default()).expect("settings serialize")
}

fn deep_merge(base: &mut Json, layer: Json) {
    match (base, layer) {
        (Json::Object(base), Json::Object(layer)) => {
            for (k, v) in layer {
                match base.get_mut(&k) {
                    Some(existing) => deep_merge(existing, v),
                    None => {
                        base.insert(k, v);
                    }
                }
            }
        }
        (base, layer) => *base = layer,
    }
}

fn parse_layer(text: &str) -> Result<Json, String> {
    let table: toml::Table = toml::from_str(text).map_err(|e| e.to_string())?;
    serde_json::to_value(table).map_err(|e| e.to_string())
}

/// Older settings stored the navigation bar choice as a boolean (`showNavigationBar`,
/// `true` = enabled). Remap it into the three-state `navigationBar` before
/// deserialization, so a plain `navigationBar` field is all specta has to export.
fn normalize_navigation_bar(mut layer: Json) -> Json {
    let Some(appearance) = layer.get_mut("appearance").and_then(Json::as_object_mut) else {
        return layer;
    };
    if appearance.contains_key("navigationBar") {
        // Already migrated; leave invalid values alone so the layer is rejected as a whole.
        return layer;
    }
    let Some(legacy) = appearance.remove("showNavigationBar") else {
        return layer;
    };
    if let Some(on) = legacy.as_bool() {
        appearance.insert("navigationBar".into(), Json::String(if on { "statusBar" } else { "hidden" }.into()));
    }
    // Not a boolean: leave it out and let the default apply, rather than silently
    // turning the navigation bar back on.
    layer
}

/// Reads one layer; `None` when missing or invalid (logged).
fn read_layer(file: &Path) -> Option<Json> {
    let text = match std::fs::read_to_string(file) {
        Ok(t) => t,
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return None,
        Err(e) => {
            tracing::warn!("cannot read {}: {e}", file.display());
            return None;
        }
    };
    match parse_layer(&text) {
        Ok(v) => Some(v),
        Err(e) => {
            tracing::warn!("{} is not valid TOML, ignoring it: {e}", file.display());
            None
        }
    }
}

/// Merges `layer` onto `merged` if the result still deserializes.
fn try_merge(merged: &mut Json, layer: Json) -> Result<(), String> {
    // Migrate the legacy boolean every layer carries it, before it can clobber
    // the three-state key coming from a lower-priority layer.
    let layer = normalize_navigation_bar(layer);
    let mut candidate = merged.clone();
    deep_merge(&mut candidate, layer);
    serde_json::from_value::<Settings>(candidate.clone()).map_err(|e| e.to_string())?;
    *merged = candidate;
    Ok(())
}

fn json_to_toml(value: &Json) -> IdeResult<toml_edit::Value> {
    Ok(match value {
        Json::Null => return Err(IdeError::invalid("null is not allowed inside a settings value")),
        Json::Bool(b) => (*b).into(),
        Json::Number(n) => match n.as_i64() {
            Some(i) => i.into(),
            None => n.as_f64().ok_or_else(|| IdeError::invalid(format!("unsupported number {n}")))?.into(),
        },
        Json::String(s) => s.as_str().into(),
        Json::Array(items) => {
            let mut arr = toml_edit::Array::new();
            for item in items {
                arr.push(json_to_toml(item)?);
            }
            arr.into()
        }
        Json::Object(map) => {
            let mut t = toml_edit::InlineTable::new();
            // TOML has no null: an unset optional field is left out.
            for (k, v) in map.iter().filter(|(_, v)| !v.is_null()) {
                t.insert(k, json_to_toml(v)?);
            }
            t.into()
        }
    })
}

/// Sets (or removes, for `None`) a dotted key in a TOML document. A new
/// `map_entry` object becomes a `[languageServers.ruff]` table rather than an
/// inline table under an explicit `[languageServers]` header.
fn set_in_document(doc: &mut DocumentMut, segments: &[&str], value: Option<toml_edit::Value>, map_entry: bool) {
    let (last, parents) = segments.split_last().expect("non-empty key");
    let mut table: &mut dyn TableLike = doc.as_table_mut();
    let mut in_inline = false;
    for seg in parents {
        if !table.get(seg).is_some_and(Item::is_table_like) {
            if value.is_none() {
                return;
            }
            // Implicit: no `[languageServers]` header above `[languageServers.ruff]`.
            let mut new = Table::new();
            new.set_implicit(true);
            table.insert(seg, Item::Table(new));
        }
        let item = table.get_mut(seg).expect("table just ensured");
        in_inline |= item.is_inline_table();
        table = item.as_table_like_mut().expect("table just ensured");
    }
    match value {
        Some(toml_edit::Value::InlineTable(t))
            if map_entry && !in_inline && !matches!(table.get(last), Some(Item::Value(_))) =>
        {
            table.insert(last, Item::Table(t.into_table()));
        }
        Some(v) => match table.get_mut(last) {
            // Keep the key's decor (comments, spacing) when replacing a value.
            Some(Item::Value(existing)) => {
                let decor = existing.decor().clone();
                *existing = v;
                *existing.decor_mut() = decor;
            }
            _ => {
                table.insert(last, Item::Value(v));
            }
        },
        None => {
            table.remove(last);
        }
    }
}

impl SettingsStore {
    pub fn load(config_dir: &Path, project_root: Option<&Path>) -> Self {
        let store = Self {
            global_file: config_dir.join("settings.toml"),
            project_file: project_root.map(|r| project_dir::path(r, PROJECT_FILE)),
            effective: RwLock::new(Settings::default()),
        };
        store.reload();
        store
    }

    pub fn file(&self, scope: SettingsScope) -> Option<&Path> {
        match scope {
            SettingsScope::Global => Some(&self.global_file),
            SettingsScope::Project => self.project_file.as_deref(),
        }
    }

    fn layers(&self) -> Vec<(SettingsScope, PathBuf)> {
        [SettingsScope::Global, SettingsScope::Project]
            .into_iter()
            .filter_map(|scope| Some((scope, self.file(scope)?.to_path_buf())))
            .collect()
    }

    fn compute(&self) -> Settings {
        let mut merged = defaults_json();
        for (scope, file) in self.layers() {
            let Some(mut layer) = read_layer(&file) else { continue };
            if scope == SettingsScope::Project {
                remove_global_settings(&mut layer);
            } else if let Some(layer) = layer.as_object_mut() {
                layer.remove("languageServerTargets");
            }
            if let Err(e) = try_merge(&mut merged, layer) {
                tracing::warn!("{} has invalid settings, ignoring it: {e}", file.display());
            }
        }
        let mut settings: Settings = serde_json::from_value(merged).unwrap_or_default();
        if let Some(root) = self.project_file.as_deref().and_then(Path::parent).and_then(Path::parent)
            && let Ok(Some(workspace)) = crate::workspace::Workspace::load(root)
            && workspace.is_container(root)
        {
            settings.general.project_name = workspace.name.clone();
            settings.project_structure.content_roots =
                workspace.projects.iter().map(|p| ide_core::ipc_path::to_ipc(p)).collect();
        }
        settings
    }

    /// Effective (merged) settings.
    pub fn effective(&self) -> Settings {
        self.effective.read().clone()
    }

    /// Sets one dotted key, e.g. `editor.fontSize`, to a JSON value in `scope`.
    /// `null` removes the key from that layer. Unknown keys and values of the
    /// wrong type are rejected with `InvalidInput`; the file is left untouched.
    pub fn set(&self, scope: SettingsScope, key: &str, value: serde_json::Value) -> IdeResult<Settings> {
        if scope == SettingsScope::Global
            && (key == "languageServerTargets" || key.starts_with("languageServerTargets."))
        {
            return Err(IdeError::invalid("language server targets belong to project settings"));
        }
        if scope == SettingsScope::Project
            && (key == "editor.customSchemes"
                || key.starts_with("editor.customSchemes.")
                || (key == "editor" && value.get("customSchemes").is_some()))
        {
            return Err(IdeError::invalid("custom color schemes belong to user settings"));
        }
        if scope == SettingsScope::Project && (key == "mcpServer" || key.starts_with("mcpServer.")) {
            return Err(IdeError::invalid("MCP server belongs to user settings"));
        }
        let file = self.file(scope).ok_or_else(|| IdeError::invalid("no project is open"))?.to_path_buf();
        let segments: Vec<&str> = key.split('.').collect();
        if segments.iter().any(|s| s.is_empty()) {
            return Err(IdeError::invalid(format!("invalid settings key {key:?}")));
        }
        let defaults = defaults_json();
        let mut cursor = &defaults;
        let mut map_entry = false;
        for (i, seg) in segments.iter().enumerate() {
            match cursor.get(seg) {
                Some(next) => cursor = next,
                // An entry of a map setting (`languageServers.rust-analyzer`): the merge below validates it.
                None if cursor.as_object().is_some_and(|m| m.is_empty()) => {
                    map_entry = i + 1 == segments.len();
                    break;
                }
                None => return Err(IdeError::invalid(format!("unknown setting {key:?}"))),
            }
        }

        let text = match std::fs::read_to_string(&file) {
            Ok(t) => t,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => String::new(),
            Err(e) => return Err(e.into()),
        };
        let mut doc: DocumentMut = text
            .parse()
            .map_err(|e| IdeError::invalid(format!("{} is not valid TOML; fix it first: {e}", file.display())))?;
        let new_value = if value.is_null() { None } else { Some(json_to_toml(&value)?) };
        set_in_document(&mut doc, &segments, new_value, map_entry);
        let new_text = doc.to_string();

        // Validate the resulting stack before touching the disk.
        let mut merged = defaults_json();
        for (layer_scope, layer_file) in self.layers() {
            let is_target = layer_scope == scope;
            let layer = if is_target { parse_layer(&new_text).ok() } else { read_layer(&layer_file) };
            let Some(mut layer) = layer else { continue };
            if layer_scope == SettingsScope::Project {
                remove_global_settings(&mut layer);
            }
            if let Err(e) = try_merge(&mut merged, layer)
                && is_target
            {
                return Err(IdeError::invalid(format!("invalid value for {key}: {e}")));
            }
        }

        if let Some(dir) = file.parent() {
            std::fs::create_dir_all(dir)?;
        }
        ide_vfs::write_atomic(&file, new_text.as_bytes())?;
        Ok(self.reload())
    }

    /// Re-reads all layers from disk.
    pub fn reload(&self) -> Settings {
        let settings = self.compute();
        *self.effective.write() = settings.clone();
        settings
    }

    /// File › Manage IDE Settings › Export Settings…: the global layer plus
    /// frontend-held IDE state (`storage`: keymaps' companions such as live
    /// templates, macros) as one JSON file.
    pub fn export_bundle(&self, path: &Path, storage: BTreeMap<String, String>) -> IdeResult<()> {
        let settings = match std::fs::read_to_string(&self.global_file) {
            Ok(t) => t,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => String::new(),
            Err(e) => return Err(e.into()),
        };
        let bundle = SettingsBundle { format: BUNDLE_FORMAT.into(), version: BUNDLE_VERSION, settings, storage };
        let json = serde_json::to_vec_pretty(&bundle).map_err(|e| IdeError::internal(e.to_string()))?;
        ide_vfs::write_atomic(path, &json)?;
        Ok(())
    }

    /// Import Settings…: replaces the global layer with the bundle's (validated
    /// first) and returns the new effective settings and the bundle's `storage`.
    pub fn import_bundle(&self, path: &Path) -> IdeResult<(Settings, BTreeMap<String, String>)> {
        let bytes = std::fs::read(path)?;
        let bundle: SettingsBundle = serde_json::from_slice(&bytes)
            .map_err(|e| IdeError::invalid(format!("not an OpenIDEA settings file: {e}")))?;
        if bundle.format != BUNDLE_FORMAT || bundle.version > BUNDLE_VERSION {
            return Err(IdeError::invalid("not an OpenIDEA settings file, or one from a newer version"));
        }
        let layer = parse_layer(&bundle.settings).map_err(|e| IdeError::invalid(format!("invalid settings: {e}")))?;
        try_merge(&mut defaults_json(), layer).map_err(|e| IdeError::invalid(format!("invalid settings: {e}")))?;
        if let Some(dir) = self.global_file.parent() {
            std::fs::create_dir_all(dir)?;
        }
        ide_vfs::write_atomic(&self.global_file, bundle.settings.as_bytes())?;
        Ok((self.reload(), bundle.storage))
    }
}

/// A JetBrains IDE's settings folder or exported archive: every
/// entry name, and the text of the entries OpenIDEA maps (the frontend does the mapping).
#[derive(serde::Serialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct JetBrainsSettings {
    pub entries: Vec<String>,
    /// Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads.
    pub files: BTreeMap<String, String>,
}

const JETBRAINS_MARKER: &str = "IntelliJ IDEA Global Settings";
const JETBRAINS_OPTIONS: [&str; 4] =
    ["options/editor-font.xml", "options/colors.scheme.xml", "options/editor.xml", "options/ide.general.xml"];
const JETBRAINS_MAX_TEXT: u64 = 4 << 20;

/// The settings of a JetBrains IDE: an exported `settings.zip`, or the IDE's own settings folder
/// (`options/`, `colors/`, … as an installed IDE keeps them).
pub fn read_jetbrains_settings(path: &Path) -> IdeResult<JetBrainsSettings> {
    if path.is_dir() { read_jetbrains_folder(path) } else { read_jetbrains_archive(path) }
}

fn is_mapped_jetbrains_file(name: &str) -> bool {
    JETBRAINS_OPTIONS.contains(&name)
        || name.strip_prefix("colors/").is_some_and(|n| !n.contains('/') && n.ends_with(".icls"))
}

/// Folders of the settings folder whose files are listed (their names say what the user customised).
const JETBRAINS_LISTED_DIRS: [&str; 6] = ["options", "colors", "keymaps", "codestyles", "templates", "inspection"];

fn read_jetbrains_folder(dir: &Path) -> IdeResult<JetBrainsSettings> {
    use std::io::Read;
    let real_dir = |path: &Path| path.symlink_metadata().is_ok_and(|m| m.is_dir());
    if !real_dir(dir) || !real_dir(&dir.join("options")) {
        return Err(IdeError::invalid("not a JetBrains settings folder"));
    }
    let mut entries = Vec::new();
    let mut files = BTreeMap::new();
    for sub in JETBRAINS_LISTED_DIRS {
        if !real_dir(&dir.join(sub)) {
            continue;
        }
        let mut names: Vec<String> = std::fs::read_dir(dir.join(sub))
            .into_iter()
            .flatten()
            .flatten()
            .filter(|e| e.file_type().is_ok_and(|t| t.is_file()))
            .map(|e| e.file_name().to_string_lossy().into_owned())
            .collect();
        names.sort();
        for file in names {
            let name = format!("{sub}/{file}");
            if is_mapped_jetbrains_file(&name) {
                let mut text = String::new();
                std::fs::File::open(dir.join(sub).join(&file))?
                    .take(JETBRAINS_MAX_TEXT)
                    .read_to_string(&mut text)
                    .map_err(|e| IdeError::invalid(format!("{name}: {e}")))?;
                files.insert(name.clone(), text);
            }
            entries.push(name);
        }
    }
    // An exported archive lists `installed.txt` when plugins came along; here they sit in `plugins/`.
    if real_dir(&dir.join("plugins")) && std::fs::read_dir(dir.join("plugins")).is_ok_and(|mut d| d.next().is_some()) {
        entries.push("installed.txt".into());
    }
    Ok(JetBrainsSettings { entries, files })
}

fn read_jetbrains_archive(path: &Path) -> IdeResult<JetBrainsSettings> {
    use std::io::Read;
    let not_jetbrains = || IdeError::invalid("not a JetBrains settings archive");
    let mut archive = zip::ZipArchive::new(std::fs::File::open(path)?).map_err(|_| not_jetbrains())?;
    let mut entries = Vec::with_capacity(archive.len());
    let mut files = BTreeMap::new();
    for i in 0..archive.len() {
        let entry = archive.by_index(i).map_err(|_| not_jetbrains())?;
        let name = entry.name().map_err(|_| not_jetbrains())?.into_owned();
        if is_mapped_jetbrains_file(&name) {
            let mut text = String::new();
            entry
                .take(JETBRAINS_MAX_TEXT)
                .read_to_string(&mut text)
                .map_err(|e| IdeError::invalid(format!("{name}: {e}")))?;
            files.insert(name.clone(), text);
        }
        entries.push(name);
    }
    if !entries.iter().any(|e| e == JETBRAINS_MARKER) {
        return Err(not_jetbrains());
    }
    Ok(JetBrainsSettings { entries, files })
}

const BUNDLE_FORMAT: &str = "openidea-settings";
const BUNDLE_VERSION: u32 = 1;

#[derive(serde::Serialize, serde::Deserialize)]
struct SettingsBundle {
    format: String,
    version: u32,
    /// The global `settings.toml`, verbatim (comments included).
    settings: String,
    #[serde(default)]
    storage: BTreeMap<String, String>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn compose_file_choices_are_project_settings_and_survive_reload() {
        let tmp = tempfile::tempdir().unwrap();
        let cfg = tmp.path().join("cfg");
        let proj = tmp.path().join("proj");
        std::fs::create_dir_all(proj.join(".openidea")).unwrap();
        let store = SettingsStore::load(&cfg, Some(&proj));
        let choices = json!({"docker/stack.yml": "kept", "manifest.yml": "excluded"});
        store.set(SettingsScope::Project, "files.composeFileOverrides", choices.clone()).unwrap();
        let loaded = SettingsStore::load(&cfg, Some(&proj)).effective();
        assert_eq!(serde_json::to_value(&loaded.files.compose_file_overrides).unwrap(), choices);
        assert!(SettingsStore::load(&cfg, None).effective().files.compose_file_overrides.is_empty());
        assert!(store.set(SettingsScope::Project, "files.composeFileOverrides", json!({"bad.yml": "yes"})).is_err());
        assert_eq!(serde_json::to_value(&store.effective().files.compose_file_overrides).unwrap(), choices);
    }

    #[test]
    fn custom_color_schemes_are_user_settings_and_survive_reload() {
        let tmp = tempfile::tempdir().unwrap();
        let cfg = tmp.path().join("cfg");
        let proj = tmp.path().join("proj");
        std::fs::create_dir_all(proj.join(".openidea")).unwrap();
        let store = SettingsStore::load(&cfg, Some(&proj));
        let schemes = json!({"custom-forest": {"name": "Forest", "parent": "dark", "attributes": {
            "keyword": {"foreground": "#99dd77", "bold": true}
        }}});
        store.set(SettingsScope::Global, "editor.customSchemes", schemes.clone()).unwrap();
        store.set(SettingsScope::Global, "editor.colorScheme", json!("custom-forest")).unwrap();
        let loaded = SettingsStore::load(&cfg, Some(&proj)).effective();
        assert_eq!(loaded.editor.color_scheme, "custom-forest");
        assert_eq!(serde_json::to_value(&loaded.editor.custom_schemes).unwrap(), schemes);
        assert!(store.set(SettingsScope::Project, "editor.customSchemes", schemes.clone()).is_err());
        assert!(
            store
                .set(SettingsScope::Project, "editor.customSchemes.custom-other", schemes["custom-forest"].clone())
                .is_err()
        );
        assert!(store.set(SettingsScope::Project, "editor", json!({"customSchemes": schemes})).is_err());
        std::fs::write(
            proj.join(".openidea/settings.toml"),
            "[editor.customSchemes.custom-forest]\nname = \"Project\"\nparent = \"light\"\nattributes = {}\n",
        )
        .unwrap();
        assert_eq!(store.reload().editor.custom_schemes["custom-forest"].name, "Forest");
        store.set(SettingsScope::Global, "editor.customSchemes", json!({})).unwrap();
        assert!(SettingsStore::load(&cfg, Some(&proj)).effective().editor.custom_schemes.is_empty());
    }

    #[test]
    fn layering_and_fallback() {
        let tmp = tempfile::tempdir().unwrap();
        let cfg = tmp.path().join("cfg");
        let proj = tmp.path().join("proj");
        std::fs::create_dir_all(&cfg).unwrap();
        std::fs::create_dir_all(proj.join(".openidea")).unwrap();
        std::fs::write(cfg.join("settings.toml"), "keymap = \"vscode\"\n[editor]\nfontSize = 15\ntabSize = 2\n")
            .unwrap();
        std::fs::write(proj.join(".openidea/settings.toml"), "[editor]\ntabSize = 8\n").unwrap();

        let s = SettingsStore::load(&cfg, Some(&proj)).effective();
        assert_eq!(s.keymap, "vscode");
        assert_eq!(s.editor.font_size, 15.0);
        assert_eq!(s.editor.tab_size, 8);
        assert_eq!(s.editor.font_family, "JetBrains Mono");

        // Invalid project layer: ignored, global still applies.
        std::fs::write(proj.join(".openidea/settings.toml"), "[editor]\ntabSize = \"wide\"\n").unwrap();
        let store = SettingsStore::load(&cfg, Some(&proj));
        assert_eq!(store.effective().editor.tab_size, 2);
        // Broken TOML in the global layer: defaults.
        std::fs::write(cfg.join("settings.toml"), "[editor\n").unwrap();
        assert_eq!(store.reload().editor.font_size, 13.0);

        let global_only = SettingsStore::load(&cfg, None);
        assert_eq!(
            global_only.set(SettingsScope::Project, "editor.fontSize", json!(1)).unwrap_err().kind,
            ide_core::error::ErrorKind::InvalidInput
        );
    }

    #[test]
    fn set_preserves_comments_and_validates() {
        let tmp = tempfile::tempdir().unwrap();
        let cfg = tmp.path().join("cfg");
        let proj = tmp.path().join("proj");
        std::fs::create_dir_all(&cfg).unwrap();
        let original = "# My settings\n\n[editor]\n# bigger is better\nfontSize = 14 # pt\nsoftWrap = true\n";
        std::fs::write(cfg.join("settings.toml"), original).unwrap();
        let store = SettingsStore::load(&cfg, Some(&proj));

        let s = store.set(SettingsScope::Global, "editor.fontSize", json!(16)).unwrap();
        assert_eq!(s.editor.font_size, 16.0);
        assert!(s.editor.soft_wrap);
        let text = std::fs::read_to_string(cfg.join("settings.toml")).unwrap();
        assert_eq!(text, "# My settings\n\n[editor]\n# bigger is better\nfontSize = 16 # pt\nsoftWrap = true\n");

        let s = store.set(SettingsScope::Global, "appearance.theme", json!("light")).unwrap();
        assert_eq!(s.appearance.theme, "light");
        let s = store.set(SettingsScope::Global, "files.exclude", json!(["**/dist"])).unwrap();
        assert_eq!(s.files.exclude, vec!["**/dist".to_string()]);
        let s = store.set(SettingsScope::Global, "editor.lineHeight", json!(22.5)).unwrap();
        assert_eq!(s.editor.line_height, 22.5);
        // An unset optional field (null) inside an object is left out.
        let ssh = json!([{ "id": "a", "name": "mac", "host": "macmini", "port": null, "user": "" }]);
        let s = store.set(SettingsScope::Global, "ssh.configs", ssh).unwrap();
        assert_eq!(s.ssh.configs[0].port, None);
        assert!(!std::fs::read_to_string(cfg.join("settings.toml")).unwrap().contains("port"));
        // Map-valued setting whose keys contain dots, replaced as a whole.
        let s = store
            .set(
                SettingsScope::Global,
                "appearance.statusBarWidgets",
                json!({"perf.memory": true, "editor.caret": false}),
            )
            .unwrap();
        assert_eq!(s.appearance.status_bar_widgets.get("perf.memory"), Some(&true));
        let s =
            store.set(SettingsScope::Global, "appearance.statusBarWidgets", json!({"editor.caret": false})).unwrap();
        assert_eq!(s.appearance.status_bar_widgets.len(), 1);
        // One entry of a map setting, set and removed on its own.
        let s = store
            .set(
                SettingsScope::Global,
                "languageServers.rust-analyzer",
                json!({"args": ["--log"], "initializationOptions": {"check": {"command": "clippy"}}}),
            )
            .unwrap();
        let ra = &s.language_servers["rust-analyzer"];
        assert!(ra.enabled);
        assert_eq!(ra.args.as_deref(), Some(&["--log".to_string()][..]));
        assert_eq!(ra.initialization_options, Some(json!({"check": {"command": "clippy"}})));
        assert_eq!(
            store
                .set(SettingsScope::Global, "languageServers.rust-analyzer", json!({"enabled": "no"}))
                .unwrap_err()
                .kind,
            ide_core::error::ErrorKind::InvalidInput
        );
        let s = store.set(SettingsScope::Global, "languageServers.rust-analyzer", json!(null)).unwrap();
        assert!(s.language_servers.is_empty());
        // New parent tables stay implicit: no empty `[languageServers]` header.
        let fresh = tmp.path().join("fresh");
        let s = SettingsStore::load(&fresh, None)
            .set(SettingsScope::Global, "languageServers.ruff.languages", json!(["python"]))
            .unwrap();
        assert!(s.language_servers["ruff"].is_custom());
        let text = std::fs::read_to_string(fresh.join("settings.toml")).unwrap();
        assert_eq!(text, "[languageServers.ruff]\nlanguages = [\"python\"]\n");
        // A whole new entry: a table of its own, still under an implicit parent.
        let added = tmp.path().join("added");
        let s = SettingsStore::load(&added, None)
            .set(
                SettingsScope::Global,
                "languageServers.ruff",
                json!({"command": "ruff", "args": ["server"], "languages": ["python"]}),
            )
            .unwrap();
        assert_eq!(s.language_servers["ruff"].command, "ruff");
        let text = std::fs::read_to_string(added.join("settings.toml")).unwrap();
        assert_eq!(text, "[languageServers.ruff]\nargs = [\"server\"]\ncommand = \"ruff\"\nlanguages = [\"python\"]\n");

        let s =
            store.set(SettingsScope::Global, "languages.ruff.configurationDirectory", json!("shared/ruff")).unwrap();
        assert_eq!(s.languages.ruff.configuration_directory, "shared/ruff");

        // Project layer is created on demand and wins.
        let s = store.set(SettingsScope::Project, "editor.fontSize", json!(12)).unwrap();
        assert_eq!(s.editor.font_size, 12.0);
        assert_eq!(std::fs::read_to_string(proj.join(".openidea/settings.toml")).unwrap(), "[editor]\nfontSize = 12\n");
        let s = store.set(SettingsScope::Project, "editor.fontSize", json!(null)).unwrap();
        assert_eq!(s.editor.font_size, 16.0);

        let err = |key: &str, v: Json| store.set(SettingsScope::Global, key, v).unwrap_err().kind;
        assert_eq!(err("editor.fontSize", json!("huge")), ide_core::error::ErrorKind::InvalidInput);
        assert_eq!(err("editor.nope", json!(1)), ide_core::error::ErrorKind::InvalidInput);
        assert_eq!(err("editor..x", json!(1)), ide_core::error::ErrorKind::InvalidInput);
        assert_eq!(store.effective().editor.font_size, 16.0);

        let reloaded = SettingsStore::load(&cfg, Some(&proj)).effective();
        assert_eq!(reloaded, store.effective());
    }

    #[test]
    fn inspection_profiles_live_in_their_layers() {
        let tmp = tempfile::tempdir().unwrap();
        let cfg = tmp.path().join("cfg");
        let proj = tmp.path().join("proj");
        std::fs::create_dir_all(&cfg).unwrap();
        let store = SettingsStore::load(&cfg, Some(&proj));
        store.set(SettingsScope::Global, "inspections.default", json!({"lsp:ruff:F401": {"enabled": false}})).unwrap();
        store.set(SettingsScope::Project, "inspections.project", json!({"lsp:ruff": {"severity": "typo"}})).unwrap();
        let s = store.set(SettingsScope::Project, "inspections.profile", json!("project")).unwrap();
        assert_eq!(s.inspections.profile, "project");
        assert_eq!(s.inspections.default["lsp:ruff:F401"].enabled, Some(false));
        assert_eq!(s.inspections.project["lsp:ruff"].severity, Some(ide_core::settings::InspectionLevel::Typo));
        assert!(store.set(SettingsScope::Project, "inspections.project", json!({"x": {"severity": "loud"}})).is_err());
        let global = std::fs::read_to_string(cfg.join("settings.toml")).unwrap();
        assert!(!global.contains("profile"), "{global}");
    }

    #[test]
    fn settings_bundle_round_trips_and_rejects_invalid_files() {
        let tmp = tempfile::tempdir().unwrap();
        let (a, b) = (tmp.path().join("a"), tmp.path().join("b"));
        std::fs::create_dir_all(&a).unwrap();
        let source = SettingsStore::load(&a, None);
        source.set(SettingsScope::Global, "editor.fontSize", json!(17)).unwrap();
        source.set(SettingsScope::Global, "general.powerSaveMode", json!(true)).unwrap();
        let file = tmp.path().join("settings.json");
        let storage = BTreeMap::from([("openidea.macros.v1".to_owned(), "[]".to_owned())]);
        source.export_bundle(&file, storage.clone()).unwrap();

        let target = SettingsStore::load(&b, None);
        let (settings, imported) = target.import_bundle(&file).unwrap();
        assert_eq!(settings.editor.font_size, 17.0);
        assert!(settings.general.power_save_mode);
        assert_eq!(imported, storage);
        assert_eq!(target.effective(), source.effective());

        let bad = tmp.path().join("bad.json");
        std::fs::write(&bad, r#"{"format":"openidea-settings","version":1,"settings":"[editor]\nfontSize = \"x\"\n"}"#)
            .unwrap();
        assert!(target.import_bundle(&bad).is_err());
        std::fs::write(&bad, r#"{"format":"other","version":1,"settings":""}"#).unwrap();
        assert!(target.import_bundle(&bad).is_err());
        assert_eq!(target.effective().editor.font_size, 17.0);
    }

    #[test]
    fn reads_jetbrains_settings_archives() {
        use std::io::Write;
        let tmp = tempfile::tempdir().unwrap();
        let write = |name: &str, entries: &[(&str, &str)]| {
            let path = tmp.path().join(name);
            let mut zip = zip::ZipWriter::new(std::fs::File::create(&path).unwrap());
            for (entry, text) in entries {
                zip.start_file(*entry, zip::write::SimpleFileOptions::default()).unwrap();
                zip.write_all(text.as_bytes()).unwrap();
            }
            zip.finish().unwrap();
            path
        };
        let ok = write(
            "settings.zip",
            &[
                (JETBRAINS_MARKER, ""),
                ("colors/_@user_Darcula.icls", "<scheme name=\"_@user_Darcula\"/>"),
                ("options/editor-font.xml", "<application/>"),
                ("options/vcs.xml", "<application/>"),
                ("keymaps/macOS.xml", "<keymap/>"),
            ],
        );
        let read = read_jetbrains_settings(&ok).unwrap();
        assert_eq!(read.entries.len(), 5);
        assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
        assert!(read_jetbrains_settings(&write("other.zip", &[("options/editor.xml", "")])).is_err());
        std::fs::write(tmp.path().join("plain.zip"), "not a zip").unwrap();
        assert!(read_jetbrains_settings(&tmp.path().join("plain.zip")).is_err());
    }

    #[test]
    fn reads_a_jetbrains_ides_own_settings_folder_like_an_exported_archive() {
        let tmp = tempfile::tempdir().unwrap();
        let config = tmp.path().join("IntelliJIdea2025.2");
        let put = |name: &str, text: &str| {
            let path = config.join(name);
            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
            std::fs::write(path, text).unwrap();
        };
        put("colors/_@user_Darcula.icls", "<scheme name=\"_@user_Darcula\"/>");
        put("colors/nested/ignored.icls", "<scheme/>");
        put("options/editor-font.xml", "<application/>");
        put("options/vcs.xml", "<application/>");
        put("keymaps/macOS.xml", "<keymap/>");
        put("plugins/Tools/lib/tools.jar", "jar");

        let read = read_jetbrains_settings(&config).unwrap();
        assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
        assert_eq!(
            read.entries,
            [
                "options/editor-font.xml",
                "options/vcs.xml",
                "colors/_@user_Darcula.icls",
                "keymaps/macOS.xml",
                "installed.txt"
            ]
        );

        assert!(read_jetbrains_settings(&tmp.path().join("missing")).is_err());
        let empty = tmp.path().join("empty");
        std::fs::create_dir_all(&empty).unwrap();
        assert!(read_jetbrains_settings(&empty).is_err(), "a folder without options/ is not a settings folder");
    }

    #[cfg(unix)]
    #[test]
    fn jetbrains_folder_does_not_follow_symlinks() {
        use std::os::unix::fs::symlink;

        let tmp = tempfile::tempdir().unwrap();
        let config = tmp.path().join("config");
        let outside = tmp.path().join("outside");
        std::fs::create_dir_all(&config).unwrap();
        std::fs::create_dir_all(&outside).unwrap();
        std::fs::write(outside.join("editor-font.xml"), "outside").unwrap();
        std::fs::write(outside.join("theme.icls"), "outside").unwrap();
        symlink(&outside, config.join("options")).unwrap();
        assert!(read_jetbrains_settings(&config).is_err(), "options/ must be a real directory");

        std::fs::remove_file(config.join("options")).unwrap();
        std::fs::create_dir(config.join("options")).unwrap();
        symlink(outside.join("editor-font.xml"), config.join("options/editor-font.xml")).unwrap();
        for sub in ["colors", "keymaps", "codestyles", "templates", "inspection", "plugins"] {
            symlink(&outside, config.join(sub)).unwrap();
        }
        let read = read_jetbrains_settings(&config).unwrap();
        assert!(read.entries.is_empty());
        assert!(read.files.is_empty());
    }

    #[test]
    fn jetbrains_folder_bounds_mapped_text_like_an_archive() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::create_dir(tmp.path().join("options")).unwrap();
        std::fs::write(tmp.path().join("options/editor-font.xml"), vec![b'x'; JETBRAINS_MAX_TEXT as usize + 1])
            .unwrap();
        let read = read_jetbrains_settings(tmp.path()).unwrap();
        assert_eq!(read.files["options/editor-font.xml"].len(), JETBRAINS_MAX_TEXT as usize);
    }

    #[test]
    fn main_toolbar_can_be_set_and_reset() {
        let tmp = tempfile::tempdir().unwrap();
        let store = SettingsStore::load(tmp.path(), None);
        let s = store
            .set(
                SettingsScope::Global,
                "appearance.mainToolbar",
                json!({"left": ["project"], "right": [], "hidden": ["vcs.branch"]}),
            )
            .unwrap();
        let toolbar = s.appearance.main_toolbar.unwrap();
        assert_eq!(toolbar.left, ["project"]);
        assert_eq!(toolbar.hidden, ["vcs.branch"]);
        let s = store.set(SettingsScope::Global, "appearance.mainToolbar", Json::Null).unwrap();
        assert_eq!(s.appearance.main_toolbar, None);
    }

    #[test]
    fn toolbar_and_status_bar_are_shown_until_hidden() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(tmp.path().join("settings.toml"), "[appearance]\ncompactMode = true\n").unwrap();
        let store = SettingsStore::load(tmp.path(), None);
        let s = store.effective();
        assert!(s.appearance.show_main_toolbar);
        assert!(s.appearance.show_status_bar);
        let s = store.set(SettingsScope::Global, "appearance.showMainToolbar", json!(false)).unwrap();
        assert!(!s.appearance.show_main_toolbar);
        let s = store.set(SettingsScope::Global, "appearance.showStatusBar", json!(false)).unwrap();
        assert!(!s.appearance.show_status_bar);
        assert!(!store.reload().appearance.show_main_toolbar);
    }

    #[test]
    fn legacy_navigation_bar_boolean_migrates_to_the_three_state_key() {
        let tmp = tempfile::tempdir().unwrap();
        // `true` → `statusBar`, where the bar lived before the three-state choice.
        std::fs::write(tmp.path().join("settings.toml"), "[appearance]\nshowNavigationBar = true\n").unwrap();
        assert_eq!(
            SettingsStore::load(tmp.path(), None).effective().appearance.navigation_bar,
            ide_core::settings::NavigationBarPosition::StatusBar
        );
        // `false` → `hidden`.
        std::fs::write(tmp.path().join("settings.toml"), "[appearance]\nshowNavigationBar = false\n").unwrap();
        assert_eq!(
            SettingsStore::load(tmp.path(), None).effective().appearance.navigation_bar,
            ide_core::settings::NavigationBarPosition::Hidden
        );
        // An explicit three-state value wins over the migrated legacy key.
        std::fs::write(
            tmp.path().join("settings.toml"),
            "[appearance]\nshowNavigationBar = true\nnavigationBar = \"top\"\n",
        )
        .unwrap();
        assert_eq!(
            SettingsStore::load(tmp.path(), None).effective().appearance.navigation_bar,
            ide_core::settings::NavigationBarPosition::Top
        );
        // A non-boolean legacy value is dropped and the default (status bar) is used.
        std::fs::write(tmp.path().join("settings.toml"), "[appearance]\nshowNavigationBar = \"everywhere\"\n").unwrap();
        assert_eq!(
            SettingsStore::load(tmp.path(), None).effective().appearance.navigation_bar,
            ide_core::settings::NavigationBarPosition::StatusBar
        );
    }

    #[test]
    fn navigation_bar_layers_migrate_without_rewriting_other_settings() {
        use ide_core::settings::NavigationBarPosition::{Hidden, StatusBar, Top};

        let tmp = tempfile::tempdir().unwrap();
        let project = tmp.path().join("project");
        std::fs::create_dir_all(project.join(".openidea")).unwrap();
        let global_file = tmp.path().join("settings.toml");
        let project_file = project.join(".openidea/settings.toml");
        let global =
            "# keep this comment\n[editor]\nfontSize = 17 # keep this too\n[appearance]\nnavigationBar = \"top\"\n";
        std::fs::write(&global_file, global).unwrap();
        let store = SettingsStore::load(tmp.path(), Some(&project));
        assert_eq!(store.effective().appearance.navigation_bar, Top);
        assert_eq!(std::fs::read_to_string(&global_file).unwrap(), global);

        for (layer, expected) in [
            ("[appearance]\nshowNavigationBar = false\n", Hidden),
            ("[appearance]\nshowNavigationBar = true\n", StatusBar),
            ("[appearance]\nnavigationBar = \"hidden\"\n", Hidden),
            ("[editor]\nfontSize = 19\n", Top),
        ] {
            std::fs::write(&project_file, layer).unwrap();
            assert_eq!(store.reload().appearance.navigation_bar, expected);
            assert_eq!(std::fs::read_to_string(&project_file).unwrap(), layer);
        }

        std::fs::remove_file(&project_file).unwrap();
        let legacy = global.replace("navigationBar = \"top\"", "showNavigationBar = false");
        std::fs::write(&global_file, &legacy).unwrap();
        assert_eq!(store.reload().appearance.navigation_bar, Hidden);
        let updated = store.set(SettingsScope::Global, "appearance.navigationBar", serde_json::json!("top")).unwrap();
        assert_eq!(updated.appearance.navigation_bar, Top);
        assert_eq!(updated.editor.font_size, 17.0);
        let written = std::fs::read_to_string(&global_file).unwrap();
        assert!(written.starts_with(&legacy));
        assert_eq!(
            store.set(SettingsScope::Global, "appearance.navigationBar", Json::Null).unwrap().appearance.navigation_bar,
            Hidden
        );
        assert_eq!(std::fs::read_to_string(&global_file).unwrap(), legacy);
    }

    #[test]
    fn mcp_server_is_default_off_and_cannot_be_enabled_by_a_project() {
        let tmp = tempfile::tempdir().unwrap();
        let config = tmp.path().join("config");
        let project = tmp.path().join("project");
        std::fs::create_dir_all(project.join(".openidea")).unwrap();
        std::fs::write(project.join(".openidea/settings.toml"), "[mcpServer]\nenabled = true\n").unwrap();
        let settings = SettingsStore::load(&config, Some(&project));
        assert!(!settings.effective().mcp_server.enabled);
        assert!(settings.set(SettingsScope::Project, "mcpServer.enabled", serde_json::json!(true)).is_err());
        assert!(
            settings
                .set(SettingsScope::Global, "mcpServer.enabled", serde_json::json!(true))
                .unwrap()
                .mcp_server
                .enabled
        );
    }
    #[test]
    fn language_server_targets_are_project_only_and_default_to_the_host() {
        let tmp = tempfile::tempdir().unwrap();
        let config = tmp.path().join("config");
        let project = tmp.path().join("project");
        std::fs::create_dir_all(&config).unwrap();
        std::fs::create_dir_all(&project).unwrap();
        std::fs::write(config.join("settings.toml"), "[languageServerTargets.php]\ntarget = 'global-target'\n")
            .unwrap();
        let settings = SettingsStore::load(&config, Some(&project));
        assert!(settings.effective().language_server_targets.is_empty());
        assert!(settings.set(SettingsScope::Global, "languageServerTargets", json!({})).is_err());
        let selected = settings
            .set(
                SettingsScope::Project,
                "languageServerTargets",
                json!({"php":{"target":"container","server":"intelephense"}}),
            )
            .unwrap();
        assert_eq!(selected.language_server_targets["php"].target, "container");
        assert_eq!(settings.reload().language_server_targets["php"].server, "intelephense");
    }
}