1mod keymap_file;
2pub mod settings_file;
3pub mod watched_json;
4
5use anyhow::{bail, 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 sqlez::{
18 bindable::{Bind, Column, StaticColumnCount},
19 statement::Statement,
20};
21use std::{collections::HashMap, num::NonZeroU32, str, sync::Arc};
22use theme::{Theme, ThemeRegistry};
23use tree_sitter::Query;
24use util::ResultExt as _;
25
26pub use keymap_file::{keymap_file_json_schema, KeymapFileContent};
27
28#[derive(Clone)]
29pub struct Settings {
30 pub buffer_font_family: FamilyId,
31 pub default_buffer_font_size: f32,
32 pub buffer_font_size: f32,
33 pub active_pane_magnification: f32,
34 pub cursor_blink: bool,
35 pub confirm_quit: bool,
36 pub hover_popover_enabled: bool,
37 pub show_completions_on_input: bool,
38 pub show_call_status_icon: bool,
39 pub vim_mode: bool,
40 pub autosave: Autosave,
41 pub default_dock_anchor: DockAnchor,
42 pub editor_defaults: EditorSettings,
43 pub editor_overrides: EditorSettings,
44 pub git: GitSettings,
45 pub git_overrides: GitSettings,
46 pub journal_defaults: JournalSettings,
47 pub journal_overrides: JournalSettings,
48 pub terminal_defaults: TerminalSettings,
49 pub terminal_overrides: TerminalSettings,
50 pub language_defaults: HashMap<Arc<str>, EditorSettings>,
51 pub language_overrides: HashMap<Arc<str>, EditorSettings>,
52 pub lsp: HashMap<Arc<str>, LspSettings>,
53 pub theme: Arc<Theme>,
54 pub telemetry_defaults: TelemetrySettings,
55 pub telemetry_overrides: TelemetrySettings,
56 pub auto_update: bool,
57}
58
59#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
60pub struct TelemetrySettings {
61 diagnostics: Option<bool>,
62 metrics: Option<bool>,
63}
64
65impl TelemetrySettings {
66 pub fn metrics(&self) -> bool {
67 self.metrics.unwrap()
68 }
69
70 pub fn diagnostics(&self) -> bool {
71 self.diagnostics.unwrap()
72 }
73
74 pub fn set_metrics(&mut self, value: bool) {
75 self.metrics = Some(value);
76 }
77
78 pub fn set_diagnostics(&mut self, value: bool) {
79 self.diagnostics = Some(value);
80 }
81}
82
83#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
84pub struct GitSettings {
85 pub git_gutter: Option<GitGutter>,
86 pub gutter_debounce: Option<u64>,
87}
88
89#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema)]
90#[serde(rename_all = "snake_case")]
91pub enum GitGutter {
92 #[default]
93 TrackedFiles,
94 Hide,
95}
96
97pub struct GitGutterConfig {}
98
99#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
100pub struct EditorSettings {
101 pub tab_size: Option<NonZeroU32>,
102 pub hard_tabs: Option<bool>,
103 pub soft_wrap: Option<SoftWrap>,
104 pub preferred_line_length: Option<u32>,
105 pub format_on_save: Option<FormatOnSave>,
106 pub remove_trailing_whitespace_on_save: Option<bool>,
107 pub ensure_final_newline_on_save: Option<bool>,
108 pub formatter: Option<Formatter>,
109 pub enable_language_server: Option<bool>,
110}
111
112#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
113#[serde(rename_all = "snake_case")]
114pub enum SoftWrap {
115 None,
116 EditorWidth,
117 PreferredLineLength,
118}
119#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
120#[serde(rename_all = "snake_case")]
121pub enum FormatOnSave {
122 On,
123 Off,
124 LanguageServer,
125 External {
126 command: String,
127 arguments: Vec<String>,
128 },
129}
130
131#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
132#[serde(rename_all = "snake_case")]
133pub enum Formatter {
134 LanguageServer,
135 External {
136 command: String,
137 arguments: Vec<String>,
138 },
139}
140
141#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
142#[serde(rename_all = "snake_case")]
143pub enum Autosave {
144 Off,
145 AfterDelay { milliseconds: u64 },
146 OnFocusChange,
147 OnWindowChange,
148}
149
150#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
151pub struct JournalSettings {
152 pub path: Option<String>,
153 pub hour_format: Option<HourFormat>,
154}
155
156impl Default for JournalSettings {
157 fn default() -> Self {
158 Self {
159 path: Some("~".into()),
160 hour_format: Some(Default::default()),
161 }
162 }
163}
164
165#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
166#[serde(rename_all = "snake_case")]
167pub enum HourFormat {
168 Hour12,
169 Hour24,
170}
171
172impl Default for HourFormat {
173 fn default() -> Self {
174 Self::Hour12
175 }
176}
177
178#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
179pub struct TerminalSettings {
180 pub shell: Option<Shell>,
181 pub working_directory: Option<WorkingDirectory>,
182 pub font_size: Option<f32>,
183 pub font_family: Option<String>,
184 pub env: Option<HashMap<String, String>>,
185 pub blinking: Option<TerminalBlink>,
186 pub alternate_scroll: Option<AlternateScroll>,
187 pub option_as_meta: Option<bool>,
188 pub copy_on_select: Option<bool>,
189}
190
191#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
192#[serde(rename_all = "snake_case")]
193pub enum TerminalBlink {
194 Off,
195 TerminalControlled,
196 On,
197}
198
199impl Default for TerminalBlink {
200 fn default() -> Self {
201 TerminalBlink::TerminalControlled
202 }
203}
204
205#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
206#[serde(rename_all = "snake_case")]
207pub enum Shell {
208 System,
209 Program(String),
210 WithArguments { program: String, args: Vec<String> },
211}
212
213impl Default for Shell {
214 fn default() -> Self {
215 Shell::System
216 }
217}
218
219#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
220#[serde(rename_all = "snake_case")]
221pub enum AlternateScroll {
222 On,
223 Off,
224}
225
226impl Default for AlternateScroll {
227 fn default() -> Self {
228 AlternateScroll::On
229 }
230}
231
232#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
233#[serde(rename_all = "snake_case")]
234pub enum WorkingDirectory {
235 CurrentProjectDirectory,
236 FirstProjectDirectory,
237 AlwaysHome,
238 Always { directory: String },
239}
240
241impl Default for WorkingDirectory {
242 fn default() -> Self {
243 Self::CurrentProjectDirectory
244 }
245}
246
247#[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Serialize, Deserialize, JsonSchema)]
248#[serde(rename_all = "snake_case")]
249pub enum DockAnchor {
250 #[default]
251 Bottom,
252 Right,
253 Expanded,
254}
255
256impl StaticColumnCount for DockAnchor {}
257impl Bind for DockAnchor {
258 fn bind(&self, statement: &Statement, start_index: i32) -> anyhow::Result<i32> {
259 match self {
260 DockAnchor::Bottom => "Bottom",
261 DockAnchor::Right => "Right",
262 DockAnchor::Expanded => "Expanded",
263 }
264 .bind(statement, start_index)
265 }
266}
267
268impl Column for DockAnchor {
269 fn column(statement: &mut Statement, start_index: i32) -> anyhow::Result<(Self, i32)> {
270 String::column(statement, start_index).and_then(|(anchor_text, next_index)| {
271 Ok((
272 match anchor_text.as_ref() {
273 "Bottom" => DockAnchor::Bottom,
274 "Right" => DockAnchor::Right,
275 "Expanded" => DockAnchor::Expanded,
276 _ => bail!("Stored dock anchor is incorrect"),
277 },
278 next_index,
279 ))
280 })
281 }
282}
283
284#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
285pub struct SettingsFileContent {
286 #[serde(default)]
287 pub projects_online_by_default: Option<bool>,
288 #[serde(default)]
289 pub buffer_font_family: Option<String>,
290 #[serde(default)]
291 pub buffer_font_size: Option<f32>,
292 #[serde(default)]
293 pub active_pane_magnification: Option<f32>,
294 #[serde(default)]
295 pub cursor_blink: Option<bool>,
296 #[serde(default)]
297 pub confirm_quit: Option<bool>,
298 #[serde(default)]
299 pub hover_popover_enabled: Option<bool>,
300 #[serde(default)]
301 pub show_completions_on_input: Option<bool>,
302 #[serde(default)]
303 pub show_call_status_icon: Option<bool>,
304 #[serde(default)]
305 pub vim_mode: Option<bool>,
306 #[serde(default)]
307 pub autosave: Option<Autosave>,
308 #[serde(default)]
309 pub default_dock_anchor: Option<DockAnchor>,
310 #[serde(flatten)]
311 pub editor: EditorSettings,
312 #[serde(default)]
313 pub journal: JournalSettings,
314 #[serde(default)]
315 pub terminal: TerminalSettings,
316 #[serde(default)]
317 pub git: Option<GitSettings>,
318 #[serde(default)]
319 #[serde(alias = "language_overrides")]
320 pub languages: HashMap<Arc<str>, EditorSettings>,
321 #[serde(default)]
322 pub lsp: HashMap<Arc<str>, LspSettings>,
323 #[serde(default)]
324 pub theme: Option<String>,
325 #[serde(default)]
326 pub telemetry: TelemetrySettings,
327 #[serde(default)]
328 pub auto_update: Option<bool>,
329}
330
331#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
332#[serde(rename_all = "snake_case")]
333pub struct LspSettings {
334 pub initialization_options: Option<Value>,
335}
336
337impl Settings {
338 /// Fill out the settings corresponding to the default.json file, overrides will be set later
339 pub fn defaults(
340 assets: impl AssetSource,
341 font_cache: &FontCache,
342 themes: &ThemeRegistry,
343 ) -> Self {
344 #[track_caller]
345 fn required<T>(value: Option<T>) -> Option<T> {
346 assert!(value.is_some(), "missing default setting value");
347 value
348 }
349
350 let defaults: SettingsFileContent = parse_json_with_comments(
351 str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
352 )
353 .unwrap();
354
355 Self {
356 buffer_font_family: font_cache
357 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
358 .unwrap(),
359 buffer_font_size: defaults.buffer_font_size.unwrap(),
360 active_pane_magnification: defaults.active_pane_magnification.unwrap(),
361 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
362 confirm_quit: defaults.confirm_quit.unwrap(),
363 cursor_blink: defaults.cursor_blink.unwrap(),
364 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
365 show_completions_on_input: defaults.show_completions_on_input.unwrap(),
366 show_call_status_icon: defaults.show_call_status_icon.unwrap(),
367 vim_mode: defaults.vim_mode.unwrap(),
368 autosave: defaults.autosave.unwrap(),
369 default_dock_anchor: defaults.default_dock_anchor.unwrap(),
370 editor_defaults: EditorSettings {
371 tab_size: required(defaults.editor.tab_size),
372 hard_tabs: required(defaults.editor.hard_tabs),
373 soft_wrap: required(defaults.editor.soft_wrap),
374 preferred_line_length: required(defaults.editor.preferred_line_length),
375 remove_trailing_whitespace_on_save: required(
376 defaults.editor.remove_trailing_whitespace_on_save,
377 ),
378 ensure_final_newline_on_save: required(
379 defaults.editor.ensure_final_newline_on_save,
380 ),
381 format_on_save: required(defaults.editor.format_on_save),
382 formatter: required(defaults.editor.formatter),
383 enable_language_server: required(defaults.editor.enable_language_server),
384 },
385 editor_overrides: Default::default(),
386 git: defaults.git.unwrap(),
387 git_overrides: Default::default(),
388 journal_defaults: defaults.journal,
389 journal_overrides: Default::default(),
390 terminal_defaults: defaults.terminal,
391 terminal_overrides: Default::default(),
392 language_defaults: defaults.languages,
393 language_overrides: Default::default(),
394 lsp: defaults.lsp.clone(),
395 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
396 telemetry_defaults: defaults.telemetry,
397 telemetry_overrides: Default::default(),
398 auto_update: defaults.auto_update.unwrap(),
399 }
400 }
401
402 // Fill out the overrride and etc. settings from the user's settings.json
403 pub fn set_user_settings(
404 &mut self,
405 data: SettingsFileContent,
406 theme_registry: &ThemeRegistry,
407 font_cache: &FontCache,
408 ) {
409 if let Some(value) = &data.buffer_font_family {
410 if let Some(id) = font_cache.load_family(&[value]).log_err() {
411 self.buffer_font_family = id;
412 }
413 }
414 if let Some(value) = &data.theme {
415 if let Some(theme) = theme_registry.get(value).log_err() {
416 self.theme = theme;
417 }
418 }
419
420 merge(&mut self.buffer_font_size, data.buffer_font_size);
421 merge(
422 &mut self.active_pane_magnification,
423 data.active_pane_magnification,
424 );
425 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
426 merge(&mut self.cursor_blink, data.cursor_blink);
427 merge(&mut self.confirm_quit, data.confirm_quit);
428 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
429 merge(
430 &mut self.show_completions_on_input,
431 data.show_completions_on_input,
432 );
433 merge(&mut self.vim_mode, data.vim_mode);
434 merge(&mut self.autosave, data.autosave);
435 merge(&mut self.default_dock_anchor, data.default_dock_anchor);
436
437 // Ensure terminal font is loaded, so we can request it in terminal_element layout
438 if let Some(terminal_font) = &data.terminal.font_family {
439 font_cache.load_family(&[terminal_font]).log_err();
440 }
441
442 self.editor_overrides = data.editor;
443 self.git_overrides = data.git.unwrap_or_default();
444 self.journal_overrides = data.journal;
445 self.terminal_defaults.font_size = data.terminal.font_size;
446 self.terminal_overrides.copy_on_select = data.terminal.copy_on_select;
447 self.terminal_overrides = data.terminal;
448 self.language_overrides = data.languages;
449 self.telemetry_overrides = data.telemetry;
450 self.lsp = data.lsp;
451 merge(&mut self.auto_update, data.auto_update);
452 }
453
454 pub fn with_language_defaults(
455 mut self,
456 language_name: impl Into<Arc<str>>,
457 overrides: EditorSettings,
458 ) -> Self {
459 self.language_defaults
460 .insert(language_name.into(), overrides);
461 self
462 }
463
464 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
465 self.language_setting(language, |settings| settings.tab_size)
466 }
467
468 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
469 self.language_setting(language, |settings| settings.hard_tabs)
470 }
471
472 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
473 self.language_setting(language, |settings| settings.soft_wrap)
474 }
475
476 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
477 self.language_setting(language, |settings| settings.preferred_line_length)
478 }
479
480 pub fn remove_trailing_whitespace_on_save(&self, language: Option<&str>) -> bool {
481 self.language_setting(language, |settings| {
482 settings.remove_trailing_whitespace_on_save.clone()
483 })
484 }
485
486 pub fn ensure_final_newline_on_save(&self, language: Option<&str>) -> bool {
487 self.language_setting(language, |settings| {
488 settings.ensure_final_newline_on_save.clone()
489 })
490 }
491
492 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
493 self.language_setting(language, |settings| settings.format_on_save.clone())
494 }
495
496 pub fn formatter(&self, language: Option<&str>) -> Formatter {
497 self.language_setting(language, |settings| settings.formatter.clone())
498 }
499
500 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
501 self.language_setting(language, |settings| settings.enable_language_server)
502 }
503
504 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
505 where
506 F: Fn(&EditorSettings) -> Option<R>,
507 {
508 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
509 .or_else(|| f(&self.editor_overrides))
510 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
511 .or_else(|| f(&self.editor_defaults))
512 .expect("missing default")
513 }
514
515 pub fn git_gutter(&self) -> GitGutter {
516 self.git_overrides.git_gutter.unwrap_or_else(|| {
517 self.git
518 .git_gutter
519 .expect("git_gutter should be some by setting setup")
520 })
521 }
522
523 fn terminal_setting<F, R: Default + Clone>(&self, f: F) -> R
524 where
525 F: Fn(&TerminalSettings) -> Option<&R>,
526 {
527 f(&self.terminal_overrides)
528 .or_else(|| f(&self.terminal_defaults))
529 .cloned()
530 .unwrap_or_else(|| R::default())
531 }
532
533 pub fn telemetry(&self) -> TelemetrySettings {
534 TelemetrySettings {
535 diagnostics: Some(self.telemetry_diagnostics()),
536 metrics: Some(self.telemetry_metrics()),
537 }
538 }
539
540 pub fn telemetry_diagnostics(&self) -> bool {
541 self.telemetry_overrides
542 .diagnostics
543 .or(self.telemetry_defaults.diagnostics)
544 .expect("missing default")
545 }
546
547 pub fn telemetry_metrics(&self) -> bool {
548 self.telemetry_overrides
549 .metrics
550 .or(self.telemetry_defaults.metrics)
551 .expect("missing default")
552 }
553
554 pub fn terminal_scroll(&self) -> AlternateScroll {
555 self.terminal_setting(|terminal_setting| terminal_setting.alternate_scroll.as_ref())
556 }
557
558 pub fn terminal_shell(&self) -> Shell {
559 self.terminal_setting(|terminal_setting| terminal_setting.shell.as_ref())
560 }
561
562 pub fn terminal_env(&self) -> HashMap<String, String> {
563 self.terminal_setting(|terminal_setting| terminal_setting.env.as_ref())
564 }
565
566 pub fn terminal_strategy(&self) -> WorkingDirectory {
567 self.terminal_setting(|terminal_setting| terminal_setting.working_directory.as_ref())
568 }
569
570 #[cfg(any(test, feature = "test-support"))]
571 pub fn test(cx: &gpui::AppContext) -> Settings {
572 Settings {
573 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
574 buffer_font_size: 14.,
575 active_pane_magnification: 1.,
576 default_buffer_font_size: 14.,
577 confirm_quit: false,
578 cursor_blink: true,
579 hover_popover_enabled: true,
580 show_completions_on_input: true,
581 show_call_status_icon: true,
582 vim_mode: false,
583 autosave: Autosave::Off,
584 default_dock_anchor: DockAnchor::Bottom,
585 editor_defaults: EditorSettings {
586 tab_size: Some(4.try_into().unwrap()),
587 hard_tabs: Some(false),
588 soft_wrap: Some(SoftWrap::None),
589 preferred_line_length: Some(80),
590 remove_trailing_whitespace_on_save: Some(true),
591 ensure_final_newline_on_save: Some(true),
592 format_on_save: Some(FormatOnSave::On),
593 formatter: Some(Formatter::LanguageServer),
594 enable_language_server: Some(true),
595 },
596 editor_overrides: Default::default(),
597 journal_defaults: Default::default(),
598 journal_overrides: Default::default(),
599 terminal_defaults: Default::default(),
600 terminal_overrides: Default::default(),
601 git: Default::default(),
602 git_overrides: Default::default(),
603 language_defaults: Default::default(),
604 language_overrides: Default::default(),
605 lsp: Default::default(),
606 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), Default::default),
607 telemetry_defaults: TelemetrySettings {
608 diagnostics: Some(true),
609 metrics: Some(true),
610 },
611 telemetry_overrides: Default::default(),
612 auto_update: true,
613 }
614 }
615
616 #[cfg(any(test, feature = "test-support"))]
617 pub fn test_async(cx: &mut gpui::TestAppContext) {
618 cx.update(|cx| {
619 let settings = Self::test(cx);
620 cx.set_global(settings);
621 });
622 }
623}
624
625pub fn settings_file_json_schema(
626 theme_names: Vec<String>,
627 language_names: &[String],
628) -> serde_json::Value {
629 let settings = SchemaSettings::draft07().with(|settings| {
630 settings.option_add_null_type = false;
631 });
632 let generator = SchemaGenerator::new(settings);
633 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
634
635 // Create a schema for a theme name.
636 let theme_name_schema = SchemaObject {
637 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
638 enum_values: Some(theme_names.into_iter().map(Value::String).collect()),
639 ..Default::default()
640 };
641
642 // Create a schema for a 'languages overrides' object, associating editor
643 // settings with specific langauges.
644 assert!(root_schema.definitions.contains_key("EditorSettings"));
645 let languages_object_schema = SchemaObject {
646 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
647 object: Some(Box::new(ObjectValidation {
648 properties: language_names
649 .iter()
650 .map(|name| {
651 (
652 name.clone(),
653 Schema::new_ref("#/definitions/EditorSettings".into()),
654 )
655 })
656 .collect(),
657 ..Default::default()
658 })),
659 ..Default::default()
660 };
661
662 // Add these new schemas as definitions, and modify properties of the root
663 // schema to reference them.
664 root_schema.definitions.extend([
665 ("ThemeName".into(), theme_name_schema.into()),
666 ("Languages".into(), languages_object_schema.into()),
667 ]);
668 let root_schema_object = &mut root_schema.schema.object.as_mut().unwrap();
669
670 root_schema_object.properties.extend([
671 (
672 "theme".to_owned(),
673 Schema::new_ref("#/definitions/ThemeName".into()),
674 ),
675 (
676 "languages".to_owned(),
677 Schema::new_ref("#/definitions/Languages".into()),
678 ),
679 // For backward compatibility
680 (
681 "language_overrides".to_owned(),
682 Schema::new_ref("#/definitions/Languages".into()),
683 ),
684 ]);
685
686 serde_json::to_value(root_schema).unwrap()
687}
688
689fn merge<T: Copy>(target: &mut T, value: Option<T>) {
690 if let Some(value) = value {
691 *target = value;
692 }
693}
694
695pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
696 Ok(serde_json::from_reader(
697 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
698 )?)
699}
700
701/// Expects the key to be unquoted, and the value to be valid JSON
702/// (e.g. values should be unquoted for numbers and bools, quoted for strings)
703pub fn write_settings_key<T: ?Sized + Serialize + Clone>(
704 settings_content: &mut String,
705 key_path: &[&str],
706 new_value: &T,
707) {
708 let mut parser = tree_sitter::Parser::new();
709 parser.set_language(tree_sitter_json::language()).unwrap();
710 let tree = parser.parse(&settings_content, None).unwrap();
711
712 let mut cursor = tree_sitter::QueryCursor::new();
713
714 let query = Query::new(
715 tree_sitter_json::language(),
716 "
717 (pair
718 key: (string) @key
719 value: (_) @value)
720 ",
721 )
722 .unwrap();
723
724 let mut depth = 0;
725 let mut first_key_start = None;
726 let mut existing_value_range = 0..settings_content.len();
727 let matches = cursor.matches(&query, tree.root_node(), settings_content.as_bytes());
728 for mat in matches {
729 if mat.captures.len() != 2 {
730 continue;
731 }
732
733 let key_range = mat.captures[0].node.byte_range();
734 let value_range = mat.captures[1].node.byte_range();
735
736 if key_range.start > existing_value_range.end {
737 break;
738 }
739
740 first_key_start.get_or_insert_with(|| key_range.start);
741
742 let found_key = settings_content
743 .get(key_range.clone())
744 .map(|key_text| key_text == format!("\"{}\"", key_path[depth]))
745 .unwrap_or(false);
746
747 if found_key {
748 existing_value_range = value_range;
749 depth += 1;
750
751 if depth == key_path.len() {
752 break;
753 } else {
754 first_key_start = None;
755 }
756 }
757 }
758
759 // We found the exact key we want, insert the new value
760 if depth == key_path.len() {
761 let new_val = serde_json::to_string_pretty(new_value)
762 .expect("Could not serialize new json field to string");
763 settings_content.replace_range(existing_value_range, &new_val);
764 } else {
765 // We have key paths, construct the sub objects
766 let new_key = key_path[depth];
767
768 // We don't have the key, construct the nested objects
769 let mut new_value = serde_json::to_value(new_value).unwrap();
770 for key in key_path[(depth + 1)..].iter().rev() {
771 new_value = serde_json::json!({ key.to_string(): new_value });
772 }
773
774 if let Some(first_key_start) = first_key_start {
775 let mut row = 0;
776 let mut column = 0;
777 for (ix, char) in settings_content.char_indices() {
778 if ix == first_key_start {
779 break;
780 }
781 if char == '\n' {
782 row += 1;
783 column = 0;
784 } else {
785 column += char.len_utf8();
786 }
787 }
788
789 if row > 0 {
790 let new_val = to_pretty_json(&new_value, column, column);
791 let content = format!(r#""{new_key}": {new_val},"#);
792 settings_content.insert_str(first_key_start, &content);
793
794 settings_content.insert_str(
795 first_key_start + content.len(),
796 &format!("\n{:width$}", ' ', width = column),
797 )
798 } else {
799 let new_val = serde_json::to_string(&new_value).unwrap();
800 let mut content = format!(r#""{new_key}": {new_val},"#);
801 content.push(' ');
802 settings_content.insert_str(first_key_start, &content);
803 }
804 } else {
805 new_value = serde_json::json!({ new_key.to_string(): new_value });
806 let indent_prefix_len = 4 * depth;
807 let new_val = to_pretty_json(&new_value, 4, indent_prefix_len);
808
809 settings_content.replace_range(existing_value_range, &new_val);
810 if depth == 0 {
811 settings_content.push('\n');
812 }
813 }
814 }
815}
816
817fn to_pretty_json(
818 value: &serde_json::Value,
819 indent_size: usize,
820 indent_prefix_len: usize,
821) -> String {
822 const SPACES: [u8; 32] = [b' '; 32];
823
824 debug_assert!(indent_size <= SPACES.len());
825 debug_assert!(indent_prefix_len <= SPACES.len());
826
827 let mut output = Vec::new();
828 let mut ser = serde_json::Serializer::with_formatter(
829 &mut output,
830 serde_json::ser::PrettyFormatter::with_indent(&SPACES[0..indent_size.min(SPACES.len())]),
831 );
832
833 value.serialize(&mut ser).unwrap();
834 let text = String::from_utf8(output).unwrap();
835
836 let mut adjusted_text = String::new();
837 for (i, line) in text.split('\n').enumerate() {
838 if i > 0 {
839 adjusted_text.push_str(str::from_utf8(&SPACES[0..indent_prefix_len]).unwrap());
840 }
841 adjusted_text.push_str(line);
842 adjusted_text.push('\n');
843 }
844 adjusted_text.pop();
845 adjusted_text
846}
847
848pub fn update_settings_file(
849 mut text: String,
850 old_file_content: SettingsFileContent,
851 update: impl FnOnce(&mut SettingsFileContent),
852) -> String {
853 let mut new_file_content = old_file_content.clone();
854
855 update(&mut new_file_content);
856
857 let old_object = to_json_object(old_file_content);
858 let new_object = to_json_object(new_file_content);
859
860 fn apply_changes_to_json_text(
861 old_object: &serde_json::Map<String, Value>,
862 new_object: &serde_json::Map<String, Value>,
863 current_key_path: Vec<&str>,
864 json_text: &mut String,
865 ) {
866 for (key, old_value) in old_object.iter() {
867 // We know that these two are from the same shape of object, so we can just unwrap
868 let new_value = new_object.get(key).unwrap();
869 if old_value != new_value {
870 match new_value {
871 Value::Bool(_) | Value::Number(_) | Value::String(_) => {
872 let mut key_path = current_key_path.clone();
873 key_path.push(key);
874 write_settings_key(json_text, &key_path, &new_value);
875 }
876 Value::Object(new_sub_object) => {
877 let mut key_path = current_key_path.clone();
878 key_path.push(key);
879 if let Value::Object(old_sub_object) = old_value {
880 apply_changes_to_json_text(
881 old_sub_object,
882 new_sub_object,
883 key_path,
884 json_text,
885 );
886 } else {
887 unimplemented!("This function doesn't support changing values from simple values to objects yet");
888 }
889 }
890 Value::Null | Value::Array(_) => {
891 unimplemented!("We only support objects and simple values");
892 }
893 }
894 }
895 }
896 }
897
898 apply_changes_to_json_text(&old_object, &new_object, vec![], &mut text);
899
900 text
901}
902
903fn to_json_object(settings_file: SettingsFileContent) -> serde_json::Map<String, Value> {
904 let tmp = serde_json::to_value(settings_file).unwrap();
905 match tmp {
906 Value::Object(map) => map,
907 _ => unreachable!("SettingsFileContent represents a JSON map"),
908 }
909}
910
911#[cfg(test)]
912mod tests {
913 use super::*;
914 use unindent::Unindent;
915
916 fn assert_new_settings<S1: Into<String>, S2: Into<String>>(
917 old_json: S1,
918 update: fn(&mut SettingsFileContent),
919 expected_new_json: S2,
920 ) {
921 let old_json = old_json.into();
922 let old_content: SettingsFileContent = serde_json::from_str(&old_json).unwrap_or_default();
923 let new_json = update_settings_file(old_json, old_content, update);
924 assert_eq!(new_json, expected_new_json.into());
925 }
926
927 #[test]
928 fn test_update_telemetry_setting_multiple_fields() {
929 assert_new_settings(
930 r#"
931 {
932 "telemetry": {
933 "metrics": false,
934 "diagnostics": false
935 }
936 }
937 "#
938 .unindent(),
939 |settings| {
940 settings.telemetry.set_diagnostics(true);
941 settings.telemetry.set_metrics(true);
942 },
943 r#"
944 {
945 "telemetry": {
946 "metrics": true,
947 "diagnostics": true
948 }
949 }
950 "#
951 .unindent(),
952 );
953 }
954
955 #[test]
956 fn test_update_telemetry_setting_weird_formatting() {
957 assert_new_settings(
958 r#"{
959 "telemetry": { "metrics": false, "diagnostics": true }
960 }"#
961 .unindent(),
962 |settings| settings.telemetry.set_diagnostics(false),
963 r#"{
964 "telemetry": { "metrics": false, "diagnostics": false }
965 }"#
966 .unindent(),
967 );
968 }
969
970 #[test]
971 fn test_update_telemetry_setting_other_fields() {
972 assert_new_settings(
973 r#"
974 {
975 "telemetry": {
976 "metrics": false,
977 "diagnostics": true
978 }
979 }
980 "#
981 .unindent(),
982 |settings| settings.telemetry.set_diagnostics(false),
983 r#"
984 {
985 "telemetry": {
986 "metrics": false,
987 "diagnostics": false
988 }
989 }
990 "#
991 .unindent(),
992 );
993 }
994
995 #[test]
996 fn test_update_telemetry_setting_empty_telemetry() {
997 assert_new_settings(
998 r#"
999 {
1000 "telemetry": {}
1001 }
1002 "#
1003 .unindent(),
1004 |settings| settings.telemetry.set_diagnostics(false),
1005 r#"
1006 {
1007 "telemetry": {
1008 "diagnostics": false
1009 }
1010 }
1011 "#
1012 .unindent(),
1013 );
1014 }
1015
1016 #[test]
1017 fn test_update_telemetry_setting_pre_existing() {
1018 assert_new_settings(
1019 r#"
1020 {
1021 "telemetry": {
1022 "diagnostics": true
1023 }
1024 }
1025 "#
1026 .unindent(),
1027 |settings| settings.telemetry.set_diagnostics(false),
1028 r#"
1029 {
1030 "telemetry": {
1031 "diagnostics": false
1032 }
1033 }
1034 "#
1035 .unindent(),
1036 );
1037 }
1038
1039 #[test]
1040 fn test_update_telemetry_setting() {
1041 assert_new_settings(
1042 "{}",
1043 |settings| settings.telemetry.set_diagnostics(true),
1044 r#"
1045 {
1046 "telemetry": {
1047 "diagnostics": true
1048 }
1049 }
1050 "#
1051 .unindent(),
1052 );
1053 }
1054
1055 #[test]
1056 fn test_update_object_empty_doc() {
1057 assert_new_settings(
1058 "",
1059 |settings| settings.telemetry.set_diagnostics(true),
1060 r#"
1061 {
1062 "telemetry": {
1063 "diagnostics": true
1064 }
1065 }
1066 "#
1067 .unindent(),
1068 );
1069 }
1070
1071 #[test]
1072 fn test_write_theme_into_settings_with_theme() {
1073 assert_new_settings(
1074 r#"
1075 {
1076 "theme": "One Dark"
1077 }
1078 "#
1079 .unindent(),
1080 |settings| settings.theme = Some("summerfruit-light".to_string()),
1081 r#"
1082 {
1083 "theme": "summerfruit-light"
1084 }
1085 "#
1086 .unindent(),
1087 );
1088 }
1089
1090 #[test]
1091 fn test_write_theme_into_empty_settings() {
1092 assert_new_settings(
1093 r#"
1094 {
1095 }
1096 "#
1097 .unindent(),
1098 |settings| settings.theme = Some("summerfruit-light".to_string()),
1099 r#"
1100 {
1101 "theme": "summerfruit-light"
1102 }
1103 "#
1104 .unindent(),
1105 );
1106 }
1107
1108 #[test]
1109 fn write_key_no_document() {
1110 assert_new_settings(
1111 "",
1112 |settings| settings.theme = Some("summerfruit-light".to_string()),
1113 r#"
1114 {
1115 "theme": "summerfruit-light"
1116 }
1117 "#
1118 .unindent(),
1119 );
1120 }
1121
1122 #[test]
1123 fn test_write_theme_into_single_line_settings_without_theme() {
1124 assert_new_settings(
1125 r#"{ "a": "", "ok": true }"#,
1126 |settings| settings.theme = Some("summerfruit-light".to_string()),
1127 r#"{ "theme": "summerfruit-light", "a": "", "ok": true }"#,
1128 );
1129 }
1130
1131 #[test]
1132 fn test_write_theme_pre_object_whitespace() {
1133 assert_new_settings(
1134 r#" { "a": "", "ok": true }"#,
1135 |settings| settings.theme = Some("summerfruit-light".to_string()),
1136 r#" { "theme": "summerfruit-light", "a": "", "ok": true }"#.unindent(),
1137 );
1138 }
1139
1140 #[test]
1141 fn test_write_theme_into_multi_line_settings_without_theme() {
1142 assert_new_settings(
1143 r#"
1144 {
1145 "a": "b"
1146 }
1147 "#
1148 .unindent(),
1149 |settings| settings.theme = Some("summerfruit-light".to_string()),
1150 r#"
1151 {
1152 "theme": "summerfruit-light",
1153 "a": "b"
1154 }
1155 "#
1156 .unindent(),
1157 );
1158 }
1159}