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, fmt::Write as _, 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 pub fn diagnostics(&self) -> bool {
70 self.diagnostics.unwrap()
71 }
72}
73
74#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
75pub struct GitSettings {
76 pub git_gutter: Option<GitGutter>,
77 pub gutter_debounce: Option<u64>,
78}
79
80#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema)]
81#[serde(rename_all = "snake_case")]
82pub enum GitGutter {
83 #[default]
84 TrackedFiles,
85 Hide,
86}
87
88pub struct GitGutterConfig {}
89
90#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
91pub struct EditorSettings {
92 pub tab_size: Option<NonZeroU32>,
93 pub hard_tabs: Option<bool>,
94 pub soft_wrap: Option<SoftWrap>,
95 pub preferred_line_length: Option<u32>,
96 pub format_on_save: Option<FormatOnSave>,
97 pub remove_trailing_whitespace_on_save: Option<bool>,
98 pub ensure_final_newline_on_save: Option<bool>,
99 pub formatter: Option<Formatter>,
100 pub enable_language_server: Option<bool>,
101}
102
103#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
104#[serde(rename_all = "snake_case")]
105pub enum SoftWrap {
106 None,
107 EditorWidth,
108 PreferredLineLength,
109}
110#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
111#[serde(rename_all = "snake_case")]
112pub enum FormatOnSave {
113 On,
114 Off,
115 LanguageServer,
116 External {
117 command: String,
118 arguments: Vec<String>,
119 },
120}
121
122#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
123#[serde(rename_all = "snake_case")]
124pub enum Formatter {
125 LanguageServer,
126 External {
127 command: String,
128 arguments: Vec<String>,
129 },
130}
131
132#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
133#[serde(rename_all = "snake_case")]
134pub enum Autosave {
135 Off,
136 AfterDelay { milliseconds: u64 },
137 OnFocusChange,
138 OnWindowChange,
139}
140
141#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
142pub struct JournalSettings {
143 pub path: Option<String>,
144 pub hour_format: Option<HourFormat>,
145}
146
147impl Default for JournalSettings {
148 fn default() -> Self {
149 Self {
150 path: Some("~".into()),
151 hour_format: Some(Default::default()),
152 }
153 }
154}
155
156#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
157#[serde(rename_all = "snake_case")]
158pub enum HourFormat {
159 Hour12,
160 Hour24,
161}
162
163impl Default for HourFormat {
164 fn default() -> Self {
165 Self::Hour12
166 }
167}
168
169#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
170pub struct TerminalSettings {
171 pub shell: Option<Shell>,
172 pub working_directory: Option<WorkingDirectory>,
173 pub font_size: Option<f32>,
174 pub font_family: Option<String>,
175 pub env: Option<HashMap<String, String>>,
176 pub blinking: Option<TerminalBlink>,
177 pub alternate_scroll: Option<AlternateScroll>,
178 pub option_as_meta: Option<bool>,
179 pub copy_on_select: Option<bool>,
180}
181
182#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
183#[serde(rename_all = "snake_case")]
184pub enum TerminalBlink {
185 Off,
186 TerminalControlled,
187 On,
188}
189
190impl Default for TerminalBlink {
191 fn default() -> Self {
192 TerminalBlink::TerminalControlled
193 }
194}
195
196#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
197#[serde(rename_all = "snake_case")]
198pub enum Shell {
199 System,
200 Program(String),
201 WithArguments { program: String, args: Vec<String> },
202}
203
204impl Default for Shell {
205 fn default() -> Self {
206 Shell::System
207 }
208}
209
210#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
211#[serde(rename_all = "snake_case")]
212pub enum AlternateScroll {
213 On,
214 Off,
215}
216
217impl Default for AlternateScroll {
218 fn default() -> Self {
219 AlternateScroll::On
220 }
221}
222
223#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
224#[serde(rename_all = "snake_case")]
225pub enum WorkingDirectory {
226 CurrentProjectDirectory,
227 FirstProjectDirectory,
228 AlwaysHome,
229 Always { directory: String },
230}
231
232impl Default for WorkingDirectory {
233 fn default() -> Self {
234 Self::CurrentProjectDirectory
235 }
236}
237
238#[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Serialize, Deserialize, JsonSchema)]
239#[serde(rename_all = "snake_case")]
240pub enum DockAnchor {
241 #[default]
242 Bottom,
243 Right,
244 Expanded,
245}
246
247impl StaticColumnCount for DockAnchor {}
248impl Bind for DockAnchor {
249 fn bind(&self, statement: &Statement, start_index: i32) -> anyhow::Result<i32> {
250 match self {
251 DockAnchor::Bottom => "Bottom",
252 DockAnchor::Right => "Right",
253 DockAnchor::Expanded => "Expanded",
254 }
255 .bind(statement, start_index)
256 }
257}
258
259impl Column for DockAnchor {
260 fn column(statement: &mut Statement, start_index: i32) -> anyhow::Result<(Self, i32)> {
261 String::column(statement, start_index).and_then(|(anchor_text, next_index)| {
262 Ok((
263 match anchor_text.as_ref() {
264 "Bottom" => DockAnchor::Bottom,
265 "Right" => DockAnchor::Right,
266 "Expanded" => DockAnchor::Expanded,
267 _ => bail!("Stored dock anchor is incorrect"),
268 },
269 next_index,
270 ))
271 })
272 }
273}
274
275#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
276pub struct SettingsFileContent {
277 #[serde(default)]
278 pub projects_online_by_default: Option<bool>,
279 #[serde(default)]
280 pub buffer_font_family: Option<String>,
281 #[serde(default)]
282 pub buffer_font_size: Option<f32>,
283 #[serde(default)]
284 pub active_pane_magnification: Option<f32>,
285 #[serde(default)]
286 pub cursor_blink: Option<bool>,
287 #[serde(default)]
288 pub confirm_quit: Option<bool>,
289 #[serde(default)]
290 pub hover_popover_enabled: Option<bool>,
291 #[serde(default)]
292 pub show_completions_on_input: Option<bool>,
293 #[serde(default)]
294 pub show_call_status_icon: Option<bool>,
295 #[serde(default)]
296 pub vim_mode: Option<bool>,
297 #[serde(default)]
298 pub autosave: Option<Autosave>,
299 #[serde(default)]
300 pub default_dock_anchor: Option<DockAnchor>,
301 #[serde(flatten)]
302 pub editor: EditorSettings,
303 #[serde(default)]
304 pub journal: JournalSettings,
305 #[serde(default)]
306 pub terminal: TerminalSettings,
307 #[serde(default)]
308 pub git: Option<GitSettings>,
309 #[serde(default)]
310 #[serde(alias = "language_overrides")]
311 pub languages: HashMap<Arc<str>, EditorSettings>,
312 #[serde(default)]
313 pub lsp: HashMap<Arc<str>, LspSettings>,
314 #[serde(default)]
315 pub theme: Option<String>,
316 #[serde(default)]
317 pub telemetry: TelemetrySettings,
318 #[serde(default)]
319 pub auto_update: Option<bool>,
320}
321
322#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
323#[serde(rename_all = "snake_case")]
324pub struct LspSettings {
325 pub initialization_options: Option<Value>,
326}
327
328impl Settings {
329 /// Fill out the settings corresponding to the default.json file, overrides will be set later
330 pub fn defaults(
331 assets: impl AssetSource,
332 font_cache: &FontCache,
333 themes: &ThemeRegistry,
334 ) -> Self {
335 #[track_caller]
336 fn required<T>(value: Option<T>) -> Option<T> {
337 assert!(value.is_some(), "missing default setting value");
338 value
339 }
340
341 let defaults: SettingsFileContent = parse_json_with_comments(
342 str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
343 )
344 .unwrap();
345
346 Self {
347 buffer_font_family: font_cache
348 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
349 .unwrap(),
350 buffer_font_size: defaults.buffer_font_size.unwrap(),
351 active_pane_magnification: defaults.active_pane_magnification.unwrap(),
352 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
353 confirm_quit: defaults.confirm_quit.unwrap(),
354 cursor_blink: defaults.cursor_blink.unwrap(),
355 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
356 show_completions_on_input: defaults.show_completions_on_input.unwrap(),
357 show_call_status_icon: defaults.show_call_status_icon.unwrap(),
358 vim_mode: defaults.vim_mode.unwrap(),
359 autosave: defaults.autosave.unwrap(),
360 default_dock_anchor: defaults.default_dock_anchor.unwrap(),
361 editor_defaults: EditorSettings {
362 tab_size: required(defaults.editor.tab_size),
363 hard_tabs: required(defaults.editor.hard_tabs),
364 soft_wrap: required(defaults.editor.soft_wrap),
365 preferred_line_length: required(defaults.editor.preferred_line_length),
366 remove_trailing_whitespace_on_save: required(
367 defaults.editor.remove_trailing_whitespace_on_save,
368 ),
369 ensure_final_newline_on_save: required(
370 defaults.editor.ensure_final_newline_on_save,
371 ),
372 format_on_save: required(defaults.editor.format_on_save),
373 formatter: required(defaults.editor.formatter),
374 enable_language_server: required(defaults.editor.enable_language_server),
375 },
376 editor_overrides: Default::default(),
377 git: defaults.git.unwrap(),
378 git_overrides: Default::default(),
379 journal_defaults: defaults.journal,
380 journal_overrides: Default::default(),
381 terminal_defaults: defaults.terminal,
382 terminal_overrides: Default::default(),
383 language_defaults: defaults.languages,
384 language_overrides: Default::default(),
385 lsp: defaults.lsp.clone(),
386 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
387 telemetry_defaults: defaults.telemetry,
388 telemetry_overrides: Default::default(),
389 auto_update: defaults.auto_update.unwrap(),
390 }
391 }
392
393 // Fill out the overrride and etc. settings from the user's settings.json
394 pub fn set_user_settings(
395 &mut self,
396 data: SettingsFileContent,
397 theme_registry: &ThemeRegistry,
398 font_cache: &FontCache,
399 ) {
400 if let Some(value) = &data.buffer_font_family {
401 if let Some(id) = font_cache.load_family(&[value]).log_err() {
402 self.buffer_font_family = id;
403 }
404 }
405 if let Some(value) = &data.theme {
406 if let Some(theme) = theme_registry.get(value).log_err() {
407 self.theme = theme;
408 }
409 }
410
411 merge(&mut self.buffer_font_size, data.buffer_font_size);
412 merge(
413 &mut self.active_pane_magnification,
414 data.active_pane_magnification,
415 );
416 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
417 merge(&mut self.cursor_blink, data.cursor_blink);
418 merge(&mut self.confirm_quit, data.confirm_quit);
419 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
420 merge(
421 &mut self.show_completions_on_input,
422 data.show_completions_on_input,
423 );
424 merge(&mut self.vim_mode, data.vim_mode);
425 merge(&mut self.autosave, data.autosave);
426 merge(&mut self.default_dock_anchor, data.default_dock_anchor);
427
428 // Ensure terminal font is loaded, so we can request it in terminal_element layout
429 if let Some(terminal_font) = &data.terminal.font_family {
430 font_cache.load_family(&[terminal_font]).log_err();
431 }
432
433 self.editor_overrides = data.editor;
434 self.git_overrides = data.git.unwrap_or_default();
435 self.journal_overrides = data.journal;
436 self.terminal_defaults.font_size = data.terminal.font_size;
437 self.terminal_overrides.copy_on_select = data.terminal.copy_on_select;
438 self.terminal_overrides = data.terminal;
439 self.language_overrides = data.languages;
440 self.telemetry_overrides = data.telemetry;
441 self.lsp = data.lsp;
442 merge(&mut self.auto_update, data.auto_update);
443 }
444
445 pub fn with_language_defaults(
446 mut self,
447 language_name: impl Into<Arc<str>>,
448 overrides: EditorSettings,
449 ) -> Self {
450 self.language_defaults
451 .insert(language_name.into(), overrides);
452 self
453 }
454
455 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
456 self.language_setting(language, |settings| settings.tab_size)
457 }
458
459 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
460 self.language_setting(language, |settings| settings.hard_tabs)
461 }
462
463 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
464 self.language_setting(language, |settings| settings.soft_wrap)
465 }
466
467 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
468 self.language_setting(language, |settings| settings.preferred_line_length)
469 }
470
471 pub fn remove_trailing_whitespace_on_save(&self, language: Option<&str>) -> bool {
472 self.language_setting(language, |settings| {
473 settings.remove_trailing_whitespace_on_save.clone()
474 })
475 }
476
477 pub fn ensure_final_newline_on_save(&self, language: Option<&str>) -> bool {
478 self.language_setting(language, |settings| {
479 settings.ensure_final_newline_on_save.clone()
480 })
481 }
482
483 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
484 self.language_setting(language, |settings| settings.format_on_save.clone())
485 }
486
487 pub fn formatter(&self, language: Option<&str>) -> Formatter {
488 self.language_setting(language, |settings| settings.formatter.clone())
489 }
490
491 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
492 self.language_setting(language, |settings| settings.enable_language_server)
493 }
494
495 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
496 where
497 F: Fn(&EditorSettings) -> Option<R>,
498 {
499 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
500 .or_else(|| f(&self.editor_overrides))
501 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
502 .or_else(|| f(&self.editor_defaults))
503 .expect("missing default")
504 }
505
506 pub fn git_gutter(&self) -> GitGutter {
507 self.git_overrides.git_gutter.unwrap_or_else(|| {
508 self.git
509 .git_gutter
510 .expect("git_gutter should be some by setting setup")
511 })
512 }
513
514 fn terminal_setting<F, R: Default + Clone>(&self, f: F) -> R
515 where
516 F: Fn(&TerminalSettings) -> Option<&R>,
517 {
518 f(&self.terminal_overrides)
519 .or_else(|| f(&self.terminal_defaults))
520 .cloned()
521 .unwrap_or_else(|| R::default())
522 }
523
524 pub fn telemetry(&self) -> TelemetrySettings {
525 TelemetrySettings {
526 diagnostics: Some(self.telemetry_diagnostics()),
527 metrics: Some(self.telemetry_metrics()),
528 }
529 }
530
531 pub fn telemetry_diagnostics(&self) -> bool {
532 self.telemetry_overrides
533 .diagnostics
534 .or(self.telemetry_defaults.diagnostics)
535 .expect("missing default")
536 }
537
538 pub fn telemetry_metrics(&self) -> bool {
539 self.telemetry_overrides
540 .metrics
541 .or(self.telemetry_defaults.metrics)
542 .expect("missing default")
543 }
544
545 pub fn terminal_scroll(&self) -> AlternateScroll {
546 self.terminal_setting(|terminal_setting| terminal_setting.alternate_scroll.as_ref())
547 }
548
549 pub fn terminal_shell(&self) -> Shell {
550 self.terminal_setting(|terminal_setting| terminal_setting.shell.as_ref())
551 }
552
553 pub fn terminal_env(&self) -> HashMap<String, String> {
554 self.terminal_setting(|terminal_setting| terminal_setting.env.as_ref())
555 }
556
557 pub fn terminal_strategy(&self) -> WorkingDirectory {
558 self.terminal_setting(|terminal_setting| terminal_setting.working_directory.as_ref())
559 }
560
561 #[cfg(any(test, feature = "test-support"))]
562 pub fn test(cx: &gpui::AppContext) -> Settings {
563 Settings {
564 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
565 buffer_font_size: 14.,
566 active_pane_magnification: 1.,
567 default_buffer_font_size: 14.,
568 confirm_quit: false,
569 cursor_blink: true,
570 hover_popover_enabled: true,
571 show_completions_on_input: true,
572 show_call_status_icon: true,
573 vim_mode: false,
574 autosave: Autosave::Off,
575 default_dock_anchor: DockAnchor::Bottom,
576 editor_defaults: EditorSettings {
577 tab_size: Some(4.try_into().unwrap()),
578 hard_tabs: Some(false),
579 soft_wrap: Some(SoftWrap::None),
580 preferred_line_length: Some(80),
581 remove_trailing_whitespace_on_save: Some(true),
582 ensure_final_newline_on_save: Some(true),
583 format_on_save: Some(FormatOnSave::On),
584 formatter: Some(Formatter::LanguageServer),
585 enable_language_server: Some(true),
586 },
587 editor_overrides: Default::default(),
588 journal_defaults: Default::default(),
589 journal_overrides: Default::default(),
590 terminal_defaults: Default::default(),
591 terminal_overrides: Default::default(),
592 git: Default::default(),
593 git_overrides: Default::default(),
594 language_defaults: Default::default(),
595 language_overrides: Default::default(),
596 lsp: Default::default(),
597 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), Default::default),
598 telemetry_defaults: TelemetrySettings {
599 diagnostics: Some(true),
600 metrics: Some(true),
601 },
602 telemetry_overrides: Default::default(),
603 auto_update: true,
604 }
605 }
606
607 #[cfg(any(test, feature = "test-support"))]
608 pub fn test_async(cx: &mut gpui::TestAppContext) {
609 cx.update(|cx| {
610 let settings = Self::test(cx);
611 cx.set_global(settings);
612 });
613 }
614}
615
616pub fn settings_file_json_schema(
617 theme_names: Vec<String>,
618 language_names: &[String],
619) -> serde_json::Value {
620 let settings = SchemaSettings::draft07().with(|settings| {
621 settings.option_add_null_type = false;
622 });
623 let generator = SchemaGenerator::new(settings);
624 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
625
626 // Create a schema for a theme name.
627 let theme_name_schema = SchemaObject {
628 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
629 enum_values: Some(theme_names.into_iter().map(Value::String).collect()),
630 ..Default::default()
631 };
632
633 // Create a schema for a 'languages overrides' object, associating editor
634 // settings with specific langauges.
635 assert!(root_schema.definitions.contains_key("EditorSettings"));
636 let languages_object_schema = SchemaObject {
637 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
638 object: Some(Box::new(ObjectValidation {
639 properties: language_names
640 .iter()
641 .map(|name| {
642 (
643 name.clone(),
644 Schema::new_ref("#/definitions/EditorSettings".into()),
645 )
646 })
647 .collect(),
648 ..Default::default()
649 })),
650 ..Default::default()
651 };
652
653 // Add these new schemas as definitions, and modify properties of the root
654 // schema to reference them.
655 root_schema.definitions.extend([
656 ("ThemeName".into(), theme_name_schema.into()),
657 ("Languages".into(), languages_object_schema.into()),
658 ]);
659 let root_schema_object = &mut root_schema.schema.object.as_mut().unwrap();
660
661 root_schema_object.properties.extend([
662 (
663 "theme".to_owned(),
664 Schema::new_ref("#/definitions/ThemeName".into()),
665 ),
666 (
667 "languages".to_owned(),
668 Schema::new_ref("#/definitions/Languages".into()),
669 ),
670 // For backward compatibility
671 (
672 "language_overrides".to_owned(),
673 Schema::new_ref("#/definitions/Languages".into()),
674 ),
675 ]);
676
677 serde_json::to_value(root_schema).unwrap()
678}
679
680/// Expects the key to be unquoted, and the value to be valid JSON
681/// (e.g. values should be unquoted for numbers and bools, quoted for strings)
682pub fn write_top_level_setting(
683 mut settings_content: String,
684 top_level_key: &str,
685 new_val: &str,
686) -> String {
687 let mut parser = tree_sitter::Parser::new();
688 parser.set_language(tree_sitter_json::language()).unwrap();
689 let tree = parser.parse(&settings_content, None).unwrap();
690
691 let mut cursor = tree_sitter::QueryCursor::new();
692
693 let query = Query::new(
694 tree_sitter_json::language(),
695 "
696 (document
697 (object
698 (pair
699 key: (string) @key
700 value: (_) @value)))
701 ",
702 )
703 .unwrap();
704
705 let mut first_key_start = None;
706 let mut existing_value_range = None;
707 let matches = cursor.matches(&query, tree.root_node(), settings_content.as_bytes());
708 for mat in matches {
709 if mat.captures.len() != 2 {
710 continue;
711 }
712
713 let key = mat.captures[0];
714 let value = mat.captures[1];
715
716 first_key_start.get_or_insert_with(|| key.node.start_byte());
717
718 if let Some(key_text) = settings_content.get(key.node.byte_range()) {
719 if key_text == format!("\"{top_level_key}\"") {
720 existing_value_range = Some(value.node.byte_range());
721 break;
722 }
723 }
724 }
725
726 match (first_key_start, existing_value_range) {
727 (None, None) => {
728 // No document, create a new object and overwrite
729 settings_content.clear();
730 write!(
731 settings_content,
732 "{{\n \"{}\": {new_val}\n}}\n",
733 top_level_key
734 )
735 .unwrap();
736 }
737
738 (_, Some(existing_value_range)) => {
739 // Existing theme key, overwrite
740 settings_content.replace_range(existing_value_range, &new_val);
741 }
742
743 (Some(first_key_start), None) => {
744 // No existing theme key, but other settings. Prepend new theme settings and
745 // match style of first key
746 let mut row = 0;
747 let mut column = 0;
748 for (ix, char) in settings_content.char_indices() {
749 if ix == first_key_start {
750 break;
751 }
752 if char == '\n' {
753 row += 1;
754 column = 0;
755 } else {
756 column += char.len_utf8();
757 }
758 }
759
760 let content = format!(r#""{top_level_key}": {new_val},"#);
761 settings_content.insert_str(first_key_start, &content);
762
763 if row > 0 {
764 settings_content.insert_str(
765 first_key_start + content.len(),
766 &format!("\n{:width$}", ' ', width = column),
767 )
768 } else {
769 settings_content.insert_str(first_key_start + content.len(), " ")
770 }
771 }
772 }
773
774 settings_content
775}
776
777fn merge<T: Copy>(target: &mut T, value: Option<T>) {
778 if let Some(value) = value {
779 *target = value;
780 }
781}
782
783pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
784 Ok(serde_json::from_reader(
785 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
786 )?)
787}
788
789#[cfg(test)]
790mod tests {
791 use crate::write_top_level_setting;
792 use unindent::Unindent;
793
794 #[test]
795 fn test_write_theme_into_settings_with_theme() {
796 let settings = r#"
797 {
798 "theme": "One Dark"
799 }
800 "#
801 .unindent();
802
803 let new_settings = r#"
804 {
805 "theme": "summerfruit-light"
806 }
807 "#
808 .unindent();
809
810 let settings_after_theme =
811 write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
812
813 assert_eq!(settings_after_theme, new_settings)
814 }
815
816 #[test]
817 fn test_write_theme_into_empty_settings() {
818 let settings = r#"
819 {
820 }
821 "#
822 .unindent();
823
824 let new_settings = r#"
825 {
826 "theme": "summerfruit-light"
827 }
828 "#
829 .unindent();
830
831 let settings_after_theme =
832 write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
833
834 assert_eq!(settings_after_theme, new_settings)
835 }
836
837 #[test]
838 fn test_write_theme_into_no_settings() {
839 let settings = "".to_string();
840
841 let new_settings = r#"
842 {
843 "theme": "summerfruit-light"
844 }
845 "#
846 .unindent();
847
848 let settings_after_theme =
849 write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
850
851 assert_eq!(settings_after_theme, new_settings)
852 }
853
854 #[test]
855 fn test_write_theme_into_single_line_settings_without_theme() {
856 let settings = r#"{ "a": "", "ok": true }"#.to_string();
857 let new_settings = r#"{ "theme": "summerfruit-light", "a": "", "ok": true }"#;
858
859 let settings_after_theme =
860 write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
861
862 assert_eq!(settings_after_theme, new_settings)
863 }
864
865 #[test]
866 fn test_write_theme_pre_object_whitespace() {
867 let settings = r#" { "a": "", "ok": true }"#.to_string();
868 let new_settings = r#" { "theme": "summerfruit-light", "a": "", "ok": true }"#;
869
870 let settings_after_theme =
871 write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
872
873 assert_eq!(settings_after_theme, new_settings)
874 }
875
876 #[test]
877 fn test_write_theme_into_multi_line_settings_without_theme() {
878 let settings = r#"
879 {
880 "a": "b"
881 }
882 "#
883 .unindent();
884
885 let new_settings = r#"
886 {
887 "theme": "summerfruit-light",
888 "a": "b"
889 }
890 "#
891 .unindent();
892
893 let settings_after_theme =
894 write_top_level_setting(settings, "theme", "\"summerfruit-light\"");
895
896 assert_eq!(settings_after_theme, new_settings)
897 }
898}