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 experiments: FeatureFlags,
24 pub projects_online_by_default: bool,
25 pub buffer_font_family: FamilyId,
26 pub default_buffer_font_size: f32,
27 pub buffer_font_size: f32,
28 pub hover_popover_enabled: bool,
29 pub show_completions_on_input: bool,
30 pub vim_mode: bool,
31 pub autosave: Autosave,
32 pub default_dock_anchor: DockAnchor,
33 pub editor_defaults: EditorSettings,
34 pub editor_overrides: EditorSettings,
35 pub git: GitSettings,
36 pub git_overrides: GitSettings,
37 pub terminal_defaults: TerminalSettings,
38 pub terminal_overrides: TerminalSettings,
39 pub language_defaults: HashMap<Arc<str>, EditorSettings>,
40 pub language_overrides: HashMap<Arc<str>, EditorSettings>,
41 pub lsp: HashMap<Arc<str>, LspSettings>,
42 pub theme: Arc<Theme>,
43 pub staff_mode: bool,
44}
45
46#[derive(Copy, Clone, Debug, Default, Deserialize, JsonSchema)]
47pub struct FeatureFlags {
48 pub experimental_themes: bool,
49}
50
51impl FeatureFlags {
52 pub fn keymap_files(&self) -> Vec<&'static str> {
53 vec![]
54 }
55}
56
57#[derive(Copy, Clone, Debug, Default, Deserialize, JsonSchema)]
58pub struct GitSettings {
59 pub git_gutter: Option<GitGutter>,
60}
61
62#[derive(Clone, Copy, Debug, Default, Deserialize, JsonSchema)]
63pub struct GitGutter {
64 pub files_included: Option<GitFilesIncluded>,
65 pub debounce_delay_millis: Option<u64>,
66}
67
68impl GitGutter {
69 pub fn files_included(&self, settings: &Settings) -> GitFilesIncluded {
70 self.files_included.unwrap_or_else(|| {
71 settings
72 .git.git_gutter.expect("git_gutter must be some in defaults.json")
73 .files_included
74 .expect("Should be some in defaults.json")
75 })
76 }
77}
78
79#[derive(Clone, Copy, Debug, Default, Deserialize, JsonSchema, PartialEq, Eq)]
80#[serde(rename_all = "snake_case")]
81pub enum GitFilesIncluded {
82 #[default]
83 All,
84 OnlyTracked,
85 None,
86}
87
88#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
89pub struct EditorSettings {
90 pub tab_size: Option<NonZeroU32>,
91 pub hard_tabs: Option<bool>,
92 pub soft_wrap: Option<SoftWrap>,
93 pub preferred_line_length: Option<u32>,
94 pub format_on_save: Option<FormatOnSave>,
95 pub formatter: Option<Formatter>,
96 pub enable_language_server: Option<bool>,
97}
98
99#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
100#[serde(rename_all = "snake_case")]
101pub enum SoftWrap {
102 None,
103 EditorWidth,
104 PreferredLineLength,
105}
106#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
107#[serde(rename_all = "snake_case")]
108pub enum FormatOnSave {
109 On,
110 Off,
111 LanguageServer,
112 External {
113 command: String,
114 arguments: Vec<String>,
115 },
116}
117
118#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
119#[serde(rename_all = "snake_case")]
120pub enum Formatter {
121 LanguageServer,
122 External {
123 command: String,
124 arguments: Vec<String>,
125 },
126}
127
128#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
129#[serde(rename_all = "snake_case")]
130pub enum Autosave {
131 Off,
132 AfterDelay { milliseconds: u64 },
133 OnFocusChange,
134 OnWindowChange,
135}
136
137#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
138pub struct TerminalSettings {
139 pub shell: Option<Shell>,
140 pub working_directory: Option<WorkingDirectory>,
141 pub font_size: Option<f32>,
142 pub font_family: Option<String>,
143 pub env: Option<HashMap<String, String>>,
144 pub blinking: Option<TerminalBlink>,
145 pub alternate_scroll: Option<AlternateScroll>,
146 pub option_as_meta: Option<bool>,
147}
148
149#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
150#[serde(rename_all = "snake_case")]
151pub enum TerminalBlink {
152 Off,
153 TerminalControlled,
154 On,
155}
156
157impl Default for TerminalBlink {
158 fn default() -> Self {
159 TerminalBlink::TerminalControlled
160 }
161}
162
163#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
164#[serde(rename_all = "snake_case")]
165pub enum Shell {
166 System,
167 Program(String),
168 WithArguments { program: String, args: Vec<String> },
169}
170
171impl Default for Shell {
172 fn default() -> Self {
173 Shell::System
174 }
175}
176
177#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
178#[serde(rename_all = "snake_case")]
179pub enum AlternateScroll {
180 On,
181 Off,
182}
183
184impl Default for AlternateScroll {
185 fn default() -> Self {
186 AlternateScroll::On
187 }
188}
189
190#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
191#[serde(rename_all = "snake_case")]
192pub enum WorkingDirectory {
193 CurrentProjectDirectory,
194 FirstProjectDirectory,
195 AlwaysHome,
196 Always { directory: String },
197}
198
199#[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Deserialize, JsonSchema)]
200#[serde(rename_all = "snake_case")]
201pub enum DockAnchor {
202 #[default]
203 Bottom,
204 Right,
205 Expanded,
206}
207
208#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
209pub struct SettingsFileContent {
210 pub experiments: Option<FeatureFlags>,
211 #[serde(default)]
212 pub projects_online_by_default: Option<bool>,
213 #[serde(default)]
214 pub buffer_font_family: Option<String>,
215 #[serde(default)]
216 pub buffer_font_size: Option<f32>,
217 #[serde(default)]
218 pub hover_popover_enabled: Option<bool>,
219 #[serde(default)]
220 pub show_completions_on_input: Option<bool>,
221 #[serde(default)]
222 pub vim_mode: Option<bool>,
223 #[serde(default)]
224 pub autosave: Option<Autosave>,
225 #[serde(default)]
226 pub default_dock_anchor: Option<DockAnchor>,
227 #[serde(flatten)]
228 pub editor: EditorSettings,
229 #[serde(default)]
230 pub terminal: TerminalSettings,
231 #[serde(default)]
232 pub git: Option<GitSettings>,
233 #[serde(default)]
234 #[serde(alias = "language_overrides")]
235 pub languages: HashMap<Arc<str>, EditorSettings>,
236 #[serde(default)]
237 pub lsp: HashMap<Arc<str>, LspSettings>,
238 #[serde(default)]
239 pub theme: Option<String>,
240 #[serde(default)]
241 pub staff_mode: Option<bool>,
242}
243
244#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
245#[serde(rename_all = "snake_case")]
246pub struct LspSettings {
247 pub initialization_options: Option<Value>,
248}
249
250impl Settings {
251 pub fn defaults(
252 assets: impl AssetSource,
253 font_cache: &FontCache,
254 themes: &ThemeRegistry,
255 ) -> Self {
256 #[track_caller]
257 fn required<T>(value: Option<T>) -> Option<T> {
258 assert!(value.is_some(), "missing default setting value");
259 value
260 }
261
262 let defaults: SettingsFileContent = parse_json_with_comments(
263 str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
264 )
265 .unwrap();
266
267 Self {
268 experiments: FeatureFlags::default(),
269 buffer_font_family: font_cache
270 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
271 .unwrap(),
272 buffer_font_size: defaults.buffer_font_size.unwrap(),
273 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
274 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
275 show_completions_on_input: defaults.show_completions_on_input.unwrap(),
276 projects_online_by_default: defaults.projects_online_by_default.unwrap(),
277 vim_mode: defaults.vim_mode.unwrap(),
278 autosave: defaults.autosave.unwrap(),
279 default_dock_anchor: defaults.default_dock_anchor.unwrap(),
280 editor_defaults: EditorSettings {
281 tab_size: required(defaults.editor.tab_size),
282 hard_tabs: required(defaults.editor.hard_tabs),
283 soft_wrap: required(defaults.editor.soft_wrap),
284 preferred_line_length: required(defaults.editor.preferred_line_length),
285 format_on_save: required(defaults.editor.format_on_save),
286 formatter: required(defaults.editor.formatter),
287 enable_language_server: required(defaults.editor.enable_language_server),
288 },
289 editor_overrides: Default::default(),
290 git: defaults.git.unwrap(),
291 git_overrides: Default::default(),
292 terminal_defaults: Default::default(),
293 terminal_overrides: Default::default(),
294 language_defaults: defaults.languages,
295 language_overrides: Default::default(),
296 lsp: defaults.lsp.clone(),
297 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
298
299 staff_mode: false,
300 }
301 }
302
303 pub fn set_user_settings(
304 &mut self,
305 data: SettingsFileContent,
306 theme_registry: &ThemeRegistry,
307 font_cache: &FontCache,
308 ) {
309 if let Some(value) = &data.buffer_font_family {
310 if let Some(id) = font_cache.load_family(&[value]).log_err() {
311 self.buffer_font_family = id;
312 }
313 }
314 if let Some(value) = &data.theme {
315 if let Some(theme) = theme_registry.get(value).log_err() {
316 self.theme = theme;
317 }
318 }
319
320 merge(
321 &mut self.projects_online_by_default,
322 data.projects_online_by_default,
323 );
324 merge(&mut self.buffer_font_size, data.buffer_font_size);
325 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
326 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
327 merge(
328 &mut self.show_completions_on_input,
329 data.show_completions_on_input,
330 );
331 merge(&mut self.vim_mode, data.vim_mode);
332 merge(&mut self.autosave, data.autosave);
333 merge(&mut self.experiments, data.experiments);
334 merge(&mut self.staff_mode, data.staff_mode);
335 merge(&mut self.default_dock_anchor, data.default_dock_anchor);
336
337 // Ensure terminal font is loaded, so we can request it in terminal_element layout
338 if let Some(terminal_font) = &data.terminal.font_family {
339 font_cache.load_family(&[terminal_font]).log_err();
340 }
341
342 self.editor_overrides = data.editor;
343 self.git_overrides = data.git.unwrap_or_default();
344 self.terminal_defaults.font_size = data.terminal.font_size;
345 self.terminal_overrides = data.terminal;
346 self.language_overrides = data.languages;
347 self.lsp = data.lsp;
348 }
349
350 pub fn with_language_defaults(
351 mut self,
352 language_name: impl Into<Arc<str>>,
353 overrides: EditorSettings,
354 ) -> Self {
355 self.language_defaults
356 .insert(language_name.into(), overrides);
357 self
358 }
359
360 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
361 self.language_setting(language, |settings| settings.tab_size)
362 }
363
364 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
365 self.language_setting(language, |settings| settings.hard_tabs)
366 }
367
368 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
369 self.language_setting(language, |settings| settings.soft_wrap)
370 }
371
372 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
373 self.language_setting(language, |settings| settings.preferred_line_length)
374 }
375
376 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
377 self.language_setting(language, |settings| settings.format_on_save.clone())
378 }
379
380 pub fn formatter(&self, language: Option<&str>) -> Formatter {
381 self.language_setting(language, |settings| settings.formatter.clone())
382 }
383
384 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
385 self.language_setting(language, |settings| settings.enable_language_server)
386 }
387
388 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
389 where
390 F: Fn(&EditorSettings) -> Option<R>,
391 {
392 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
393 .or_else(|| f(&self.editor_overrides))
394 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
395 .or_else(|| f(&self.editor_defaults))
396 .expect("missing default")
397 }
398
399 pub fn git_gutter(&self) -> GitGutter {
400 self.git_overrides.git_gutter.unwrap_or_else(|| {
401 self.git
402 .git_gutter
403 .expect("git_gutter should be some by setting setup")
404 })
405 }
406
407 #[cfg(any(test, feature = "test-support"))]
408 pub fn test(cx: &gpui::AppContext) -> Settings {
409 Settings {
410 experiments: FeatureFlags::default(),
411 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
412 buffer_font_size: 14.,
413 default_buffer_font_size: 14.,
414 hover_popover_enabled: true,
415 show_completions_on_input: true,
416 vim_mode: false,
417 autosave: Autosave::Off,
418 default_dock_anchor: DockAnchor::Bottom,
419 editor_defaults: EditorSettings {
420 tab_size: Some(4.try_into().unwrap()),
421 hard_tabs: Some(false),
422 soft_wrap: Some(SoftWrap::None),
423 preferred_line_length: Some(80),
424 format_on_save: Some(FormatOnSave::On),
425 formatter: Some(Formatter::LanguageServer),
426 enable_language_server: Some(true),
427 },
428 editor_overrides: Default::default(),
429 terminal_defaults: Default::default(),
430 terminal_overrides: Default::default(),
431 git: GitSettings {
432 git_gutter: Some(GitGutter {
433 files_included: Some(GitFilesIncluded::All),
434 debounce_delay_millis: None,
435 }),
436 },
437 git_overrides: Default::default(),
438 language_defaults: Default::default(),
439 language_overrides: Default::default(),
440 lsp: Default::default(),
441 projects_online_by_default: true,
442 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), Default::default),
443 staff_mode: false,
444 }
445 }
446
447 #[cfg(any(test, feature = "test-support"))]
448 pub fn test_async(cx: &mut gpui::TestAppContext) {
449 cx.update(|cx| {
450 let settings = Self::test(cx);
451 cx.set_global(settings);
452 });
453 }
454}
455
456pub fn settings_file_json_schema(
457 theme_names: Vec<String>,
458 language_names: &[String],
459) -> serde_json::Value {
460 let settings = SchemaSettings::draft07().with(|settings| {
461 settings.option_add_null_type = false;
462 });
463 let generator = SchemaGenerator::new(settings);
464 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
465
466 // Create a schema for a theme name.
467 let theme_name_schema = SchemaObject {
468 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
469 enum_values: Some(theme_names.into_iter().map(Value::String).collect()),
470 ..Default::default()
471 };
472
473 // Create a schema for a 'languages overrides' object, associating editor
474 // settings with specific langauges.
475 assert!(root_schema.definitions.contains_key("EditorSettings"));
476 let languages_object_schema = SchemaObject {
477 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
478 object: Some(Box::new(ObjectValidation {
479 properties: language_names
480 .iter()
481 .map(|name| {
482 (
483 name.clone(),
484 Schema::new_ref("#/definitions/EditorSettings".into()),
485 )
486 })
487 .collect(),
488 ..Default::default()
489 })),
490 ..Default::default()
491 };
492
493 // Add these new schemas as definitions, and modify properties of the root
494 // schema to reference them.
495 root_schema.definitions.extend([
496 ("ThemeName".into(), theme_name_schema.into()),
497 ("Languages".into(), languages_object_schema.into()),
498 ]);
499 let root_schema_object = &mut root_schema.schema.object.as_mut().unwrap();
500
501 // Avoid automcomplete for non-user facing settings
502 root_schema_object.properties.remove("staff_mode");
503 root_schema_object.properties.extend([
504 (
505 "theme".to_owned(),
506 Schema::new_ref("#/definitions/ThemeName".into()),
507 ),
508 (
509 "languages".to_owned(),
510 Schema::new_ref("#/definitions/Languages".into()),
511 ),
512 // For backward compatibility
513 (
514 "language_overrides".to_owned(),
515 Schema::new_ref("#/definitions/Languages".into()),
516 ),
517 ]);
518
519 serde_json::to_value(root_schema).unwrap()
520}
521
522fn merge<T: Copy>(target: &mut T, value: Option<T>) {
523 if let Some(value) = value {
524 *target = value;
525 }
526}
527
528pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
529 Ok(serde_json::from_reader(
530 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
531 )?)
532}