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