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