1mod keymap_file;
2pub mod settings_file;
3
4use anyhow::Result;
5use gpui::{
6 font_cache::{FamilyId, FontCache},
7 AssetSource,
8};
9use schemars::{
10 gen::{SchemaGenerator, SchemaSettings},
11 schema::{InstanceType, ObjectValidation, Schema, SchemaObject, SingleOrVec},
12 JsonSchema,
13};
14use serde::{de::DeserializeOwned, Deserialize};
15use serde_json::Value;
16use std::{collections::HashMap, fmt::Write as _, num::NonZeroU32, str, sync::Arc};
17use theme::{Theme, ThemeRegistry};
18use tree_sitter::Query;
19use util::ResultExt as _;
20
21pub use keymap_file::{keymap_file_json_schema, KeymapFileContent};
22
23#[derive(Clone)]
24pub struct Settings {
25 pub experiments: FeatureFlags,
26 pub projects_online_by_default: bool,
27 pub buffer_font_family: FamilyId,
28 pub default_buffer_font_size: f32,
29 pub buffer_font_size: f32,
30 pub hover_popover_enabled: bool,
31 pub show_completions_on_input: bool,
32 pub vim_mode: bool,
33 pub autosave: Autosave,
34 pub default_dock_anchor: DockAnchor,
35 pub editor_defaults: EditorSettings,
36 pub editor_overrides: EditorSettings,
37 pub git: GitSettings,
38 pub git_overrides: GitSettings,
39 pub terminal_defaults: TerminalSettings,
40 pub terminal_overrides: TerminalSettings,
41 pub language_defaults: HashMap<Arc<str>, EditorSettings>,
42 pub language_overrides: HashMap<Arc<str>, EditorSettings>,
43 pub lsp: HashMap<Arc<str>, LspSettings>,
44 pub theme: Arc<Theme>,
45 pub staff_mode: bool,
46}
47
48#[derive(Copy, Clone, Debug, Default, Deserialize, JsonSchema)]
49pub struct FeatureFlags {
50 pub experimental_themes: bool,
51}
52
53impl FeatureFlags {
54 pub fn keymap_files(&self) -> Vec<&'static str> {
55 vec![]
56 }
57}
58
59#[derive(Copy, Clone, Debug, Default, Deserialize, JsonSchema)]
60pub struct GitSettings {
61 pub git_gutter: Option<GitGutter>,
62 pub gutter_debounce: Option<u64>,
63}
64
65#[derive(Clone, Copy, Debug, Default, Deserialize, JsonSchema)]
66#[serde(rename_all = "snake_case")]
67pub enum GitGutter {
68 #[default]
69 TrackedFiles,
70 Hide,
71}
72
73pub struct GitGutterConfig {}
74
75#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
76pub struct EditorSettings {
77 pub tab_size: Option<NonZeroU32>,
78 pub hard_tabs: Option<bool>,
79 pub soft_wrap: Option<SoftWrap>,
80 pub preferred_line_length: Option<u32>,
81 pub format_on_save: Option<FormatOnSave>,
82 pub formatter: Option<Formatter>,
83 pub enable_language_server: Option<bool>,
84}
85
86#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
87#[serde(rename_all = "snake_case")]
88pub enum SoftWrap {
89 None,
90 EditorWidth,
91 PreferredLineLength,
92}
93#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
94#[serde(rename_all = "snake_case")]
95pub enum FormatOnSave {
96 On,
97 Off,
98 LanguageServer,
99 External {
100 command: String,
101 arguments: Vec<String>,
102 },
103}
104
105#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
106#[serde(rename_all = "snake_case")]
107pub enum Formatter {
108 LanguageServer,
109 External {
110 command: String,
111 arguments: Vec<String>,
112 },
113}
114
115#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
116#[serde(rename_all = "snake_case")]
117pub enum Autosave {
118 Off,
119 AfterDelay { milliseconds: u64 },
120 OnFocusChange,
121 OnWindowChange,
122}
123
124#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
125pub struct TerminalSettings {
126 pub shell: Option<Shell>,
127 pub working_directory: Option<WorkingDirectory>,
128 pub font_size: Option<f32>,
129 pub font_family: Option<String>,
130 pub env: Option<HashMap<String, String>>,
131 pub blinking: Option<TerminalBlink>,
132 pub alternate_scroll: Option<AlternateScroll>,
133 pub option_as_meta: Option<bool>,
134 pub copy_on_select: Option<bool>,
135}
136
137#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
138#[serde(rename_all = "snake_case")]
139pub enum TerminalBlink {
140 Off,
141 TerminalControlled,
142 On,
143}
144
145impl Default for TerminalBlink {
146 fn default() -> Self {
147 TerminalBlink::TerminalControlled
148 }
149}
150
151#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
152#[serde(rename_all = "snake_case")]
153pub enum Shell {
154 System,
155 Program(String),
156 WithArguments { program: String, args: Vec<String> },
157}
158
159impl Default for Shell {
160 fn default() -> Self {
161 Shell::System
162 }
163}
164
165#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
166#[serde(rename_all = "snake_case")]
167pub enum AlternateScroll {
168 On,
169 Off,
170}
171
172impl Default for AlternateScroll {
173 fn default() -> Self {
174 AlternateScroll::On
175 }
176}
177
178#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
179#[serde(rename_all = "snake_case")]
180pub enum WorkingDirectory {
181 CurrentProjectDirectory,
182 FirstProjectDirectory,
183 AlwaysHome,
184 Always { directory: String },
185}
186
187#[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Deserialize, JsonSchema)]
188#[serde(rename_all = "snake_case")]
189pub enum DockAnchor {
190 #[default]
191 Bottom,
192 Right,
193 Expanded,
194}
195
196#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
197pub struct SettingsFileContent {
198 pub experiments: Option<FeatureFlags>,
199 #[serde(default)]
200 pub projects_online_by_default: Option<bool>,
201 #[serde(default)]
202 pub buffer_font_family: Option<String>,
203 #[serde(default)]
204 pub buffer_font_size: Option<f32>,
205 #[serde(default)]
206 pub hover_popover_enabled: Option<bool>,
207 #[serde(default)]
208 pub show_completions_on_input: Option<bool>,
209 #[serde(default)]
210 pub vim_mode: Option<bool>,
211 #[serde(default)]
212 pub autosave: Option<Autosave>,
213 #[serde(default)]
214 pub default_dock_anchor: Option<DockAnchor>,
215 #[serde(flatten)]
216 pub editor: EditorSettings,
217 #[serde(default)]
218 pub terminal: TerminalSettings,
219 #[serde(default)]
220 pub git: Option<GitSettings>,
221 #[serde(default)]
222 #[serde(alias = "language_overrides")]
223 pub languages: HashMap<Arc<str>, EditorSettings>,
224 #[serde(default)]
225 pub lsp: HashMap<Arc<str>, LspSettings>,
226 #[serde(default)]
227 pub theme: Option<String>,
228 #[serde(default)]
229 pub staff_mode: Option<bool>,
230}
231
232#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
233#[serde(rename_all = "snake_case")]
234pub struct LspSettings {
235 pub initialization_options: Option<Value>,
236}
237
238impl Settings {
239 pub fn defaults(
240 assets: impl AssetSource,
241 font_cache: &FontCache,
242 themes: &ThemeRegistry,
243 ) -> Self {
244 #[track_caller]
245 fn required<T>(value: Option<T>) -> Option<T> {
246 assert!(value.is_some(), "missing default setting value");
247 value
248 }
249
250 let defaults: SettingsFileContent = parse_json_with_comments(
251 str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
252 )
253 .unwrap();
254
255 Self {
256 experiments: FeatureFlags::default(),
257 buffer_font_family: font_cache
258 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
259 .unwrap(),
260 buffer_font_size: defaults.buffer_font_size.unwrap(),
261 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
262 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
263 show_completions_on_input: defaults.show_completions_on_input.unwrap(),
264 projects_online_by_default: defaults.projects_online_by_default.unwrap(),
265 vim_mode: defaults.vim_mode.unwrap(),
266 autosave: defaults.autosave.unwrap(),
267 default_dock_anchor: defaults.default_dock_anchor.unwrap(),
268 editor_defaults: EditorSettings {
269 tab_size: required(defaults.editor.tab_size),
270 hard_tabs: required(defaults.editor.hard_tabs),
271 soft_wrap: required(defaults.editor.soft_wrap),
272 preferred_line_length: required(defaults.editor.preferred_line_length),
273 format_on_save: required(defaults.editor.format_on_save),
274 formatter: required(defaults.editor.formatter),
275 enable_language_server: required(defaults.editor.enable_language_server),
276 },
277 editor_overrides: Default::default(),
278 git: defaults.git.unwrap(),
279 git_overrides: Default::default(),
280 terminal_defaults: defaults.terminal,
281 terminal_overrides: Default::default(),
282 language_defaults: defaults.languages,
283 language_overrides: Default::default(),
284 lsp: defaults.lsp.clone(),
285 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
286
287 staff_mode: false,
288 }
289 }
290
291 pub fn set_user_settings(
292 &mut self,
293 data: SettingsFileContent,
294 theme_registry: &ThemeRegistry,
295 font_cache: &FontCache,
296 ) {
297 if let Some(value) = &data.buffer_font_family {
298 if let Some(id) = font_cache.load_family(&[value]).log_err() {
299 self.buffer_font_family = id;
300 }
301 }
302 if let Some(value) = &data.theme {
303 if let Some(theme) = theme_registry.get(value).log_err() {
304 self.theme = theme;
305 }
306 }
307
308 merge(
309 &mut self.projects_online_by_default,
310 data.projects_online_by_default,
311 );
312 merge(&mut self.buffer_font_size, data.buffer_font_size);
313 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
314 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
315 merge(
316 &mut self.show_completions_on_input,
317 data.show_completions_on_input,
318 );
319 merge(&mut self.vim_mode, data.vim_mode);
320 merge(&mut self.autosave, data.autosave);
321 merge(&mut self.experiments, data.experiments);
322 merge(&mut self.staff_mode, data.staff_mode);
323 merge(&mut self.default_dock_anchor, data.default_dock_anchor);
324
325 // Ensure terminal font is loaded, so we can request it in terminal_element layout
326 if let Some(terminal_font) = &data.terminal.font_family {
327 font_cache.load_family(&[terminal_font]).log_err();
328 }
329
330 self.editor_overrides = data.editor;
331 self.git_overrides = data.git.unwrap_or_default();
332 self.terminal_defaults.font_size = data.terminal.font_size;
333 self.terminal_overrides.copy_on_select = data.terminal.copy_on_select;
334 self.terminal_overrides = data.terminal;
335 self.language_overrides = data.languages;
336 self.lsp = data.lsp;
337 }
338
339 pub fn with_language_defaults(
340 mut self,
341 language_name: impl Into<Arc<str>>,
342 overrides: EditorSettings,
343 ) -> Self {
344 self.language_defaults
345 .insert(language_name.into(), overrides);
346 self
347 }
348
349 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
350 self.language_setting(language, |settings| settings.tab_size)
351 }
352
353 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
354 self.language_setting(language, |settings| settings.hard_tabs)
355 }
356
357 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
358 self.language_setting(language, |settings| settings.soft_wrap)
359 }
360
361 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
362 self.language_setting(language, |settings| settings.preferred_line_length)
363 }
364
365 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
366 self.language_setting(language, |settings| settings.format_on_save.clone())
367 }
368
369 pub fn formatter(&self, language: Option<&str>) -> Formatter {
370 self.language_setting(language, |settings| settings.formatter.clone())
371 }
372
373 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
374 self.language_setting(language, |settings| settings.enable_language_server)
375 }
376
377 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
378 where
379 F: Fn(&EditorSettings) -> Option<R>,
380 {
381 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
382 .or_else(|| f(&self.editor_overrides))
383 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
384 .or_else(|| f(&self.editor_defaults))
385 .expect("missing default")
386 }
387
388 pub fn git_gutter(&self) -> GitGutter {
389 self.git_overrides.git_gutter.unwrap_or_else(|| {
390 self.git
391 .git_gutter
392 .expect("git_gutter should be some by setting setup")
393 })
394 }
395
396 #[cfg(any(test, feature = "test-support"))]
397 pub fn test(cx: &gpui::AppContext) -> Settings {
398 Settings {
399 experiments: FeatureFlags::default(),
400 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
401 buffer_font_size: 14.,
402 default_buffer_font_size: 14.,
403 hover_popover_enabled: true,
404 show_completions_on_input: true,
405 vim_mode: false,
406 autosave: Autosave::Off,
407 default_dock_anchor: DockAnchor::Bottom,
408 editor_defaults: EditorSettings {
409 tab_size: Some(4.try_into().unwrap()),
410 hard_tabs: Some(false),
411 soft_wrap: Some(SoftWrap::None),
412 preferred_line_length: Some(80),
413 format_on_save: Some(FormatOnSave::On),
414 formatter: Some(Formatter::LanguageServer),
415 enable_language_server: Some(true),
416 },
417 editor_overrides: Default::default(),
418 terminal_defaults: Default::default(),
419 terminal_overrides: Default::default(),
420 git: Default::default(),
421 git_overrides: Default::default(),
422 language_defaults: Default::default(),
423 language_overrides: Default::default(),
424 lsp: Default::default(),
425 projects_online_by_default: true,
426 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), Default::default),
427 staff_mode: false,
428 }
429 }
430
431 #[cfg(any(test, feature = "test-support"))]
432 pub fn test_async(cx: &mut gpui::TestAppContext) {
433 cx.update(|cx| {
434 let settings = Self::test(cx);
435 cx.set_global(settings);
436 });
437 }
438}
439
440pub fn settings_file_json_schema(
441 theme_names: Vec<String>,
442 language_names: &[String],
443) -> serde_json::Value {
444 let settings = SchemaSettings::draft07().with(|settings| {
445 settings.option_add_null_type = false;
446 });
447 let generator = SchemaGenerator::new(settings);
448 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
449
450 // Create a schema for a theme name.
451 let theme_name_schema = SchemaObject {
452 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
453 enum_values: Some(theme_names.into_iter().map(Value::String).collect()),
454 ..Default::default()
455 };
456
457 // Create a schema for a 'languages overrides' object, associating editor
458 // settings with specific langauges.
459 assert!(root_schema.definitions.contains_key("EditorSettings"));
460 let languages_object_schema = SchemaObject {
461 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
462 object: Some(Box::new(ObjectValidation {
463 properties: language_names
464 .iter()
465 .map(|name| {
466 (
467 name.clone(),
468 Schema::new_ref("#/definitions/EditorSettings".into()),
469 )
470 })
471 .collect(),
472 ..Default::default()
473 })),
474 ..Default::default()
475 };
476
477 // Add these new schemas as definitions, and modify properties of the root
478 // schema to reference them.
479 root_schema.definitions.extend([
480 ("ThemeName".into(), theme_name_schema.into()),
481 ("Languages".into(), languages_object_schema.into()),
482 ]);
483 let root_schema_object = &mut root_schema.schema.object.as_mut().unwrap();
484
485 // Avoid automcomplete for non-user facing settings
486 root_schema_object.properties.remove("staff_mode");
487 root_schema_object.properties.extend([
488 (
489 "theme".to_owned(),
490 Schema::new_ref("#/definitions/ThemeName".into()),
491 ),
492 (
493 "languages".to_owned(),
494 Schema::new_ref("#/definitions/Languages".into()),
495 ),
496 // For backward compatibility
497 (
498 "language_overrides".to_owned(),
499 Schema::new_ref("#/definitions/Languages".into()),
500 ),
501 ]);
502
503 serde_json::to_value(root_schema).unwrap()
504}
505
506pub fn write_top_level_setting(
507 mut settings_content: String,
508 top_level_key: &str,
509 new_val: &str,
510) -> String {
511 let mut parser = tree_sitter::Parser::new();
512 parser.set_language(tree_sitter_json::language()).unwrap();
513 let tree = parser.parse(&settings_content, None).unwrap();
514
515 let mut cursor = tree_sitter::QueryCursor::new();
516
517 let query = Query::new(
518 tree_sitter_json::language(),
519 "
520 (document
521 (object
522 (pair
523 key: (string) @key
524 value: (_) @value)))
525 ",
526 )
527 .unwrap();
528
529 let mut first_key_start = None;
530 let mut existing_value_range = None;
531 let matches = cursor.matches(&query, tree.root_node(), settings_content.as_bytes());
532 for mat in matches {
533 if mat.captures.len() != 2 {
534 continue;
535 }
536
537 let key = mat.captures[0];
538 let value = mat.captures[1];
539
540 first_key_start.get_or_insert_with(|| key.node.start_byte());
541
542 if let Some(key_text) = settings_content.get(key.node.byte_range()) {
543 if key_text == format!("\"{top_level_key}\"") {
544 existing_value_range = Some(value.node.byte_range());
545 break;
546 }
547 }
548 }
549
550 match (first_key_start, existing_value_range) {
551 (None, None) => {
552 // No document, create a new object and overwrite
553 settings_content.clear();
554 write!(
555 settings_content,
556 "{{\n \"{}\": \"{new_val}\"\n}}\n",
557 top_level_key
558 )
559 .unwrap();
560 }
561
562 (_, Some(existing_value_range)) => {
563 // Existing theme key, overwrite
564 settings_content.replace_range(existing_value_range, &format!("\"{new_val}\""));
565 }
566
567 (Some(first_key_start), None) => {
568 // No existing theme key, but other settings. Prepend new theme settings and
569 // match style of first key
570 let mut row = 0;
571 let mut column = 0;
572 for (ix, char) in settings_content.char_indices() {
573 if ix == first_key_start {
574 break;
575 }
576 if char == '\n' {
577 row += 1;
578 column = 0;
579 } else {
580 column += char.len_utf8();
581 }
582 }
583
584 let content = format!(r#""{top_level_key}": "{new_val}","#);
585 settings_content.insert_str(first_key_start, &content);
586
587 if row > 0 {
588 settings_content.insert_str(
589 first_key_start + content.len(),
590 &format!("\n{:width$}", ' ', width = column),
591 )
592 } else {
593 settings_content.insert_str(first_key_start + content.len(), " ")
594 }
595 }
596 }
597
598 settings_content
599}
600
601fn merge<T: Copy>(target: &mut T, value: Option<T>) {
602 if let Some(value) = value {
603 *target = value;
604 }
605}
606
607pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
608 Ok(serde_json::from_reader(
609 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
610 )?)
611}
612
613#[cfg(test)]
614mod tests {
615 use crate::write_top_level_setting;
616 use unindent::Unindent;
617
618 #[test]
619 fn test_write_theme_into_settings_with_theme() {
620 let settings = r#"
621 {
622 "theme": "one-dark"
623 }
624 "#
625 .unindent();
626
627 let new_settings = r#"
628 {
629 "theme": "summerfruit-light"
630 }
631 "#
632 .unindent();
633
634 let settings_after_theme = write_top_level_setting(settings, "theme", "summerfruit-light");
635
636 assert_eq!(settings_after_theme, new_settings)
637 }
638
639 #[test]
640 fn test_write_theme_into_empty_settings() {
641 let settings = r#"
642 {
643 }
644 "#
645 .unindent();
646
647 let new_settings = r#"
648 {
649 "theme": "summerfruit-light"
650 }
651 "#
652 .unindent();
653
654 let settings_after_theme = write_top_level_setting(settings, "theme", "summerfruit-light");
655
656 assert_eq!(settings_after_theme, new_settings)
657 }
658
659 #[test]
660 fn test_write_theme_into_no_settings() {
661 let settings = "".to_string();
662
663 let new_settings = r#"
664 {
665 "theme": "summerfruit-light"
666 }
667 "#
668 .unindent();
669
670 let settings_after_theme = write_top_level_setting(settings, "theme", "summerfruit-light");
671
672 assert_eq!(settings_after_theme, new_settings)
673 }
674
675 #[test]
676 fn test_write_theme_into_single_line_settings_without_theme() {
677 let settings = r#"{ "a": "", "ok": true }"#.to_string();
678 let new_settings = r#"{ "theme": "summerfruit-light", "a": "", "ok": true }"#;
679
680 let settings_after_theme = write_top_level_setting(settings, "theme", "summerfruit-light");
681
682 assert_eq!(settings_after_theme, new_settings)
683 }
684
685 #[test]
686 fn test_write_theme_pre_object_whitespace() {
687 let settings = r#" { "a": "", "ok": true }"#.to_string();
688 let new_settings = r#" { "theme": "summerfruit-light", "a": "", "ok": true }"#;
689
690 let settings_after_theme = write_top_level_setting(settings, "theme", "summerfruit-light");
691
692 assert_eq!(settings_after_theme, new_settings)
693 }
694
695 #[test]
696 fn test_write_theme_into_multi_line_settings_without_theme() {
697 let settings = r#"
698 {
699 "a": "b"
700 }
701 "#
702 .unindent();
703
704 let new_settings = r#"
705 {
706 "theme": "summerfruit-light",
707 "a": "b"
708 }
709 "#
710 .unindent();
711
712 let settings_after_theme = write_top_level_setting(settings, "theme", "summerfruit-light");
713
714 assert_eq!(settings_after_theme, new_settings)
715 }
716}