1mod keymap_file;
  2
  3use anyhow::Result;
  4use gpui::{
  5    font_cache::{FamilyId, FontCache},
  6    AssetSource,
  7};
  8use schemars::{
  9    gen::{SchemaGenerator, SchemaSettings},
 10    schema::{InstanceType, ObjectValidation, Schema, SchemaObject, SingleOrVec},
 11    JsonSchema,
 12};
 13use serde::{de::DeserializeOwned, Deserialize};
 14use serde_json::Value;
 15use std::{collections::HashMap, num::NonZeroU32, str, sync::Arc};
 16use theme::{Theme, ThemeRegistry};
 17use util::ResultExt as _;
 18
 19pub use keymap_file::{keymap_file_json_schema, KeymapFileContent};
 20
 21#[derive(Clone)]
 22pub struct Settings {
 23    pub projects_online_by_default: bool,
 24    pub buffer_font_family: FamilyId,
 25    pub default_buffer_font_size: f32,
 26    pub buffer_font_size: f32,
 27    pub hover_popover_enabled: bool,
 28    pub show_completions_on_input: bool,
 29    pub vim_mode: bool,
 30    pub autosave: Autosave,
 31    pub editor_defaults: EditorSettings,
 32    pub editor_overrides: EditorSettings,
 33    pub terminal_defaults: TerminalSettings,
 34    pub terminal_overrides: TerminalSettings,
 35    pub language_defaults: HashMap<Arc<str>, EditorSettings>,
 36    pub language_overrides: HashMap<Arc<str>, EditorSettings>,
 37    pub theme: Arc<Theme>,
 38}
 39
 40#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
 41pub struct EditorSettings {
 42    pub tab_size: Option<NonZeroU32>,
 43    pub hard_tabs: Option<bool>,
 44    pub soft_wrap: Option<SoftWrap>,
 45    pub preferred_line_length: Option<u32>,
 46    pub format_on_save: Option<FormatOnSave>,
 47    pub enable_language_server: Option<bool>,
 48}
 49
 50#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
 51#[serde(rename_all = "snake_case")]
 52pub enum SoftWrap {
 53    None,
 54    EditorWidth,
 55    PreferredLineLength,
 56}
 57
 58#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
 59#[serde(rename_all = "snake_case")]
 60pub enum FormatOnSave {
 61    Off,
 62    LanguageServer,
 63    External {
 64        command: String,
 65        arguments: Vec<String>,
 66    },
 67}
 68
 69#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
 70#[serde(rename_all = "snake_case")]
 71pub enum Autosave {
 72    Off,
 73    AfterDelay { milliseconds: u64 },
 74    OnFocusChange,
 75    OnWindowChange,
 76}
 77
 78#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
 79pub struct TerminalSettings {
 80    pub shell: Option<Shell>,
 81    pub working_directory: Option<WorkingDirectory>,
 82    pub font_size: Option<f32>,
 83    pub font_family: Option<String>,
 84    pub env: Option<Vec<(String, String)>>,
 85}
 86
 87#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
 88#[serde(rename_all = "snake_case")]
 89pub enum Shell {
 90    System,
 91    Program(String),
 92    WithArguments { program: String, args: Vec<String> },
 93}
 94
 95impl Default for Shell {
 96    fn default() -> Self {
 97        Shell::System
 98    }
 99}
100
101#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
102#[serde(rename_all = "snake_case")]
103pub enum WorkingDirectory {
104    CurrentProjectDirectory,
105    FirstProjectDirectory,
106    AlwaysHome,
107    Always { directory: String },
108}
109
110#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
111pub struct SettingsFileContent {
112    #[serde(default)]
113    pub projects_online_by_default: Option<bool>,
114    #[serde(default)]
115    pub buffer_font_family: Option<String>,
116    #[serde(default)]
117    pub buffer_font_size: Option<f32>,
118    #[serde(default)]
119    pub hover_popover_enabled: Option<bool>,
120    #[serde(default)]
121    pub show_completions_on_input: Option<bool>,
122    #[serde(default)]
123    pub vim_mode: Option<bool>,
124    #[serde(default)]
125    pub autosave: Option<Autosave>,
126    #[serde(flatten)]
127    pub editor: EditorSettings,
128    #[serde(default)]
129    pub terminal: TerminalSettings,
130    #[serde(default)]
131    #[serde(alias = "language_overrides")]
132    pub languages: HashMap<Arc<str>, EditorSettings>,
133    #[serde(default)]
134    pub theme: Option<String>,
135}
136
137impl Settings {
138    pub fn defaults(
139        assets: impl AssetSource,
140        font_cache: &FontCache,
141        themes: &ThemeRegistry,
142    ) -> Self {
143        fn required<T>(value: Option<T>) -> Option<T> {
144            assert!(value.is_some(), "missing default setting value");
145            value
146        }
147
148        let defaults: SettingsFileContent = parse_json_with_comments(
149            str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
150        )
151        .unwrap();
152
153        Self {
154            buffer_font_family: font_cache
155                .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
156                .unwrap(),
157            buffer_font_size: defaults.buffer_font_size.unwrap(),
158            default_buffer_font_size: defaults.buffer_font_size.unwrap(),
159            hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
160            show_completions_on_input: defaults.show_completions_on_input.unwrap(),
161            projects_online_by_default: defaults.projects_online_by_default.unwrap(),
162            vim_mode: defaults.vim_mode.unwrap(),
163            autosave: defaults.autosave.unwrap(),
164            editor_defaults: EditorSettings {
165                tab_size: required(defaults.editor.tab_size),
166                hard_tabs: required(defaults.editor.hard_tabs),
167                soft_wrap: required(defaults.editor.soft_wrap),
168                preferred_line_length: required(defaults.editor.preferred_line_length),
169                format_on_save: required(defaults.editor.format_on_save),
170                enable_language_server: required(defaults.editor.enable_language_server),
171            },
172            editor_overrides: Default::default(),
173            terminal_defaults: Default::default(),
174            terminal_overrides: Default::default(),
175            language_defaults: defaults.languages,
176            language_overrides: Default::default(),
177            theme: themes.get(&defaults.theme.unwrap()).unwrap(),
178        }
179    }
180
181    pub fn set_user_settings(
182        &mut self,
183        data: SettingsFileContent,
184        theme_registry: &ThemeRegistry,
185        font_cache: &FontCache,
186    ) {
187        if let Some(value) = &data.buffer_font_family {
188            if let Some(id) = font_cache.load_family(&[value]).log_err() {
189                self.buffer_font_family = id;
190            }
191        }
192        if let Some(value) = &data.theme {
193            if let Some(theme) = theme_registry.get(&value.to_string()).log_err() {
194                self.theme = theme;
195            }
196        }
197
198        merge(
199            &mut self.projects_online_by_default,
200            data.projects_online_by_default,
201        );
202        merge(&mut self.buffer_font_size, data.buffer_font_size);
203        merge(&mut self.default_buffer_font_size, data.buffer_font_size);
204        merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
205        merge(
206            &mut self.show_completions_on_input,
207            data.show_completions_on_input,
208        );
209        merge(&mut self.vim_mode, data.vim_mode);
210        merge(&mut self.autosave, data.autosave);
211
212        // Ensure terminal font is loaded, so we can request it in terminal_element layout
213        if let Some(terminal_font) = &data.terminal.font_family {
214            font_cache.load_family(&[terminal_font]).log_err();
215        }
216
217        self.editor_overrides = data.editor;
218        self.terminal_defaults.font_size = data.terminal.font_size;
219        self.terminal_overrides = data.terminal;
220        self.language_overrides = data.languages;
221    }
222
223    pub fn with_language_defaults(
224        mut self,
225        language_name: impl Into<Arc<str>>,
226        overrides: EditorSettings,
227    ) -> Self {
228        self.language_defaults
229            .insert(language_name.into(), overrides);
230        self
231    }
232
233    pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
234        self.language_setting(language, |settings| settings.tab_size)
235    }
236
237    pub fn hard_tabs(&self, language: Option<&str>) -> bool {
238        self.language_setting(language, |settings| settings.hard_tabs)
239    }
240
241    pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
242        self.language_setting(language, |settings| settings.soft_wrap)
243    }
244
245    pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
246        self.language_setting(language, |settings| settings.preferred_line_length)
247    }
248
249    pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
250        self.language_setting(language, |settings| settings.format_on_save.clone())
251    }
252
253    pub fn enable_language_server(&self, language: Option<&str>) -> bool {
254        self.language_setting(language, |settings| settings.enable_language_server)
255    }
256
257    fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
258    where
259        F: Fn(&EditorSettings) -> Option<R>,
260    {
261        None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
262            .or_else(|| f(&self.editor_overrides))
263            .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
264            .or_else(|| f(&self.editor_defaults))
265            .expect("missing default")
266    }
267
268    #[cfg(any(test, feature = "test-support"))]
269    pub fn test(cx: &gpui::AppContext) -> Settings {
270        Settings {
271            buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
272            buffer_font_size: 14.,
273            default_buffer_font_size: 14.,
274            hover_popover_enabled: true,
275            show_completions_on_input: true,
276            vim_mode: false,
277            autosave: Autosave::Off,
278            editor_defaults: EditorSettings {
279                tab_size: Some(4.try_into().unwrap()),
280                hard_tabs: Some(false),
281                soft_wrap: Some(SoftWrap::None),
282                preferred_line_length: Some(80),
283                format_on_save: Some(FormatOnSave::LanguageServer),
284                enable_language_server: Some(true),
285            },
286            editor_overrides: Default::default(),
287            terminal_defaults: Default::default(),
288            terminal_overrides: Default::default(),
289            language_defaults: Default::default(),
290            language_overrides: Default::default(),
291            projects_online_by_default: true,
292            theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), || Default::default()),
293        }
294    }
295
296    #[cfg(any(test, feature = "test-support"))]
297    pub fn test_async(cx: &mut gpui::TestAppContext) {
298        cx.update(|cx| {
299            let settings = Self::test(cx);
300            cx.set_global(settings.clone());
301        });
302    }
303}
304
305pub fn settings_file_json_schema(
306    theme_names: Vec<String>,
307    language_names: &[String],
308) -> serde_json::Value {
309    let settings = SchemaSettings::draft07().with(|settings| {
310        settings.option_add_null_type = false;
311    });
312    let generator = SchemaGenerator::new(settings);
313    let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
314
315    // Create a schema for a theme name.
316    let theme_name_schema = SchemaObject {
317        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
318        enum_values: Some(
319            theme_names
320                .into_iter()
321                .map(|name| Value::String(name))
322                .collect(),
323        ),
324        ..Default::default()
325    };
326
327    // Create a schema for a 'languages overrides' object, associating editor
328    // settings with specific langauges.
329    assert!(root_schema.definitions.contains_key("EditorSettings"));
330    let languages_object_schema = SchemaObject {
331        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
332        object: Some(Box::new(ObjectValidation {
333            properties: language_names
334                .iter()
335                .map(|name| {
336                    (
337                        name.clone(),
338                        Schema::new_ref("#/definitions/EditorSettings".into()),
339                    )
340                })
341                .collect(),
342            ..Default::default()
343        })),
344        ..Default::default()
345    };
346
347    // Add these new schemas as definitions, and modify properties of the root
348    // schema to reference them.
349    root_schema.definitions.extend([
350        ("ThemeName".into(), theme_name_schema.into()),
351        ("Languages".into(), languages_object_schema.into()),
352    ]);
353    root_schema
354        .schema
355        .object
356        .as_mut()
357        .unwrap()
358        .properties
359        .extend([
360            (
361                "theme".to_owned(),
362                Schema::new_ref("#/definitions/ThemeName".into()),
363            ),
364            (
365                "languages".to_owned(),
366                Schema::new_ref("#/definitions/Languages".into()),
367            ),
368            // For backward compatibility
369            (
370                "language_overrides".to_owned(),
371                Schema::new_ref("#/definitions/Languages".into()),
372            ),
373        ]);
374
375    serde_json::to_value(root_schema).unwrap()
376}
377
378fn merge<T: Copy>(target: &mut T, value: Option<T>) {
379    if let Some(value) = value {
380        *target = value;
381    }
382}
383
384pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
385    Ok(serde_json::from_reader(
386        json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
387    )?)
388}