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