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