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