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