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