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