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