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