Skip to main content

fresh/
partial_config.rs

1//! Partial configuration types for layered config merging.
2//!
3//! This module provides `Option`-wrapped versions of all config structs,
4//! enabling a 4-level overlay architecture (System → User → Project → Session).
5
6use crate::config::{
7    ClipboardConfig, CursorStyle, FileBrowserConfig, FileExplorerConfig, FormatterConfig,
8    Keybinding, KeybindingMapName, KeymapConfig, LanguageConfig, LineEndingOption, OnSaveAction,
9    PluginConfig, TerminalConfig, ThemeName, WarningsConfig,
10};
11use crate::types::LspLanguageConfig;
12use serde::{Deserialize, Serialize};
13use std::collections::HashMap;
14
15/// Trait for merging configuration layers.
16/// Higher precedence values (self) override lower precedence (other).
17pub trait Merge {
18    /// Merge values from a lower-precedence layer into this layer.
19    /// Values already set in self take precedence over values in other.
20    fn merge_from(&mut self, other: &Self);
21}
22
23impl<T: Clone> Merge for Option<T> {
24    fn merge_from(&mut self, other: &Self) {
25        if self.is_none() {
26            *self = other.clone();
27        }
28    }
29}
30
31/// Merge two HashMaps where self's entries take precedence.
32/// Entries from other are added if not present in self.
33fn merge_hashmap<K: Clone + Eq + std::hash::Hash, V: Clone>(
34    target: &mut Option<HashMap<K, V>>,
35    other: &Option<HashMap<K, V>>,
36) {
37    match (target, other) {
38        (Some(t), Some(o)) => {
39            for (key, value) in o {
40                t.entry(key.clone()).or_insert_with(|| value.clone());
41            }
42        }
43        (t @ None, Some(o)) => {
44            *t = Some(o.clone());
45        }
46        _ => {}
47    }
48}
49
50/// Merge two HashMaps where values implement Merge (for recursive merging).
51fn merge_hashmap_recursive<K, V>(target: &mut Option<HashMap<K, V>>, other: &Option<HashMap<K, V>>)
52where
53    K: Clone + Eq + std::hash::Hash,
54    V: Clone + Merge + Default,
55{
56    match (target, other) {
57        (Some(t), Some(o)) => {
58            for (key, value) in o {
59                t.entry(key.clone())
60                    .and_modify(|existing| existing.merge_from(value))
61                    .or_insert_with(|| value.clone());
62            }
63        }
64        (t @ None, Some(o)) => {
65            *t = Some(o.clone());
66        }
67        _ => {}
68    }
69}
70
71/// Partial configuration where all fields are optional.
72/// Represents a single configuration layer (User, Project, or Session).
73#[derive(Debug, Clone, Default, Deserialize, Serialize)]
74#[serde(default)]
75pub struct PartialConfig {
76    pub version: Option<u32>,
77    pub theme: Option<ThemeName>,
78    pub locale: Option<String>,
79    pub check_for_updates: Option<bool>,
80    pub editor: Option<PartialEditorConfig>,
81    pub file_explorer: Option<PartialFileExplorerConfig>,
82    pub file_browser: Option<PartialFileBrowserConfig>,
83    pub clipboard: Option<PartialClipboardConfig>,
84    pub terminal: Option<PartialTerminalConfig>,
85    pub keybindings: Option<Vec<Keybinding>>,
86    pub keybinding_maps: Option<HashMap<String, KeymapConfig>>,
87    pub active_keybinding_map: Option<KeybindingMapName>,
88    pub languages: Option<HashMap<String, PartialLanguageConfig>>,
89    pub default_language: Option<String>,
90    pub lsp: Option<HashMap<String, LspLanguageConfig>>,
91    pub universal_lsp: Option<HashMap<String, LspLanguageConfig>>,
92    pub warnings: Option<PartialWarningsConfig>,
93    pub plugins: Option<HashMap<String, PartialPluginConfig>>,
94    pub packages: Option<PartialPackagesConfig>,
95}
96
97impl Merge for PartialConfig {
98    fn merge_from(&mut self, other: &Self) {
99        self.version.merge_from(&other.version);
100        self.theme.merge_from(&other.theme);
101        self.locale.merge_from(&other.locale);
102        self.check_for_updates.merge_from(&other.check_for_updates);
103
104        // Nested structs: merge recursively
105        merge_partial(&mut self.editor, &other.editor);
106        merge_partial(&mut self.file_explorer, &other.file_explorer);
107        merge_partial(&mut self.file_browser, &other.file_browser);
108        merge_partial(&mut self.clipboard, &other.clipboard);
109        merge_partial(&mut self.terminal, &other.terminal);
110        merge_partial(&mut self.warnings, &other.warnings);
111        merge_partial(&mut self.packages, &other.packages);
112
113        // Lists: higher precedence replaces (per design doc)
114        self.keybindings.merge_from(&other.keybindings);
115
116        // HashMaps: merge entries, higher precedence wins on key collision
117        merge_hashmap(&mut self.keybinding_maps, &other.keybinding_maps);
118        merge_hashmap_recursive(&mut self.languages, &other.languages);
119        self.default_language.merge_from(&other.default_language);
120        merge_hashmap(&mut self.lsp, &other.lsp);
121        merge_hashmap(&mut self.universal_lsp, &other.universal_lsp);
122        merge_hashmap_recursive(&mut self.plugins, &other.plugins);
123
124        self.active_keybinding_map
125            .merge_from(&other.active_keybinding_map);
126    }
127}
128
129/// Helper to merge nested partial structs.
130fn merge_partial<T: Merge + Clone>(target: &mut Option<T>, other: &Option<T>) {
131    match (target, other) {
132        (Some(t), Some(o)) => t.merge_from(o),
133        (t @ None, Some(o)) => *t = Some(o.clone()),
134        _ => {}
135    }
136}
137
138/// Partial editor configuration.
139#[derive(Debug, Clone, Default, Deserialize, Serialize)]
140#[serde(default)]
141pub struct PartialEditorConfig {
142    pub use_tabs: Option<bool>,
143    pub tab_size: Option<usize>,
144    pub auto_indent: Option<bool>,
145    pub auto_close: Option<bool>,
146    pub auto_surround: Option<bool>,
147    pub animations: Option<bool>,
148    pub cursor_jump_animation: Option<bool>,
149    pub line_numbers: Option<bool>,
150    pub relative_line_numbers: Option<bool>,
151    pub scroll_offset: Option<usize>,
152    pub syntax_highlighting: Option<bool>,
153    pub highlight_current_line: Option<bool>,
154    pub highlight_current_column: Option<bool>,
155    pub line_wrap: Option<bool>,
156    pub wrap_indent: Option<bool>,
157    pub wrap_column: Option<Option<usize>>,
158    pub page_width: Option<Option<usize>>,
159    pub highlight_timeout_ms: Option<u64>,
160    pub snapshot_interval: Option<usize>,
161    pub large_file_threshold_bytes: Option<u64>,
162    pub estimated_line_length: Option<usize>,
163    pub enable_inlay_hints: Option<bool>,
164    pub enable_semantic_tokens_full: Option<bool>,
165    pub diagnostics_inline_text: Option<bool>,
166    pub recovery_enabled: Option<bool>,
167    pub auto_recovery_save_interval_secs: Option<u32>,
168    pub auto_save_enabled: Option<bool>,
169    pub auto_save_interval_secs: Option<u32>,
170    pub hot_exit: Option<bool>,
171    pub confirm_quit: Option<bool>,
172    pub restore_previous_session: Option<bool>,
173    pub skip_session_restore_when_files_passed: Option<bool>,
174    pub auto_create_empty_buffer_on_last_buffer_close: Option<bool>,
175    pub highlight_context_bytes: Option<usize>,
176    pub mouse_hover_enabled: Option<bool>,
177    pub mouse_hover_delay_ms: Option<u64>,
178    pub double_click_time_ms: Option<u64>,
179    pub auto_revert_poll_interval_ms: Option<u64>,
180    pub read_concurrency: Option<usize>,
181    pub file_tree_poll_interval_ms: Option<u64>,
182    pub default_line_ending: Option<LineEndingOption>,
183    pub trim_trailing_whitespace_on_save: Option<bool>,
184    pub ensure_final_newline_on_save: Option<bool>,
185    pub highlight_matching_brackets: Option<bool>,
186    pub rainbow_brackets: Option<bool>,
187    pub cursor_style: Option<CursorStyle>,
188    pub keyboard_disambiguate_escape_codes: Option<bool>,
189    pub keyboard_report_event_types: Option<bool>,
190    pub keyboard_report_alternate_keys: Option<bool>,
191    pub keyboard_report_all_keys_as_escape_codes: Option<bool>,
192    pub completion_popup_auto_show: Option<bool>,
193    pub quick_suggestions: Option<bool>,
194    pub quick_suggestions_delay_ms: Option<u64>,
195    pub suggest_on_trigger_characters: Option<bool>,
196    pub show_menu_bar: Option<bool>,
197    pub menu_bar_mnemonics: Option<bool>,
198    pub show_tab_bar: Option<bool>,
199    pub show_status_bar: Option<bool>,
200    pub status_bar: Option<crate::config::StatusBarConfig>,
201    pub show_prompt_line: Option<bool>,
202    pub show_vertical_scrollbar: Option<bool>,
203    pub show_horizontal_scrollbar: Option<bool>,
204    pub show_tilde: Option<bool>,
205    pub use_terminal_bg: Option<bool>,
206    pub set_window_title: Option<bool>,
207    pub rulers: Option<Vec<usize>>,
208    pub whitespace_show: Option<bool>,
209    pub whitespace_spaces_leading: Option<bool>,
210    pub whitespace_spaces_inner: Option<bool>,
211    pub whitespace_spaces_trailing: Option<bool>,
212    pub whitespace_tabs_leading: Option<bool>,
213    pub whitespace_tabs_inner: Option<bool>,
214    pub whitespace_tabs_trailing: Option<bool>,
215}
216
217impl Merge for PartialEditorConfig {
218    fn merge_from(&mut self, other: &Self) {
219        self.use_tabs.merge_from(&other.use_tabs);
220        self.tab_size.merge_from(&other.tab_size);
221        self.auto_indent.merge_from(&other.auto_indent);
222        self.auto_close.merge_from(&other.auto_close);
223        self.auto_surround.merge_from(&other.auto_surround);
224        self.animations.merge_from(&other.animations);
225        self.cursor_jump_animation
226            .merge_from(&other.cursor_jump_animation);
227        self.line_numbers.merge_from(&other.line_numbers);
228        self.relative_line_numbers
229            .merge_from(&other.relative_line_numbers);
230        self.scroll_offset.merge_from(&other.scroll_offset);
231        self.syntax_highlighting
232            .merge_from(&other.syntax_highlighting);
233        self.line_wrap.merge_from(&other.line_wrap);
234        self.wrap_indent.merge_from(&other.wrap_indent);
235        self.wrap_column.merge_from(&other.wrap_column);
236        self.page_width.merge_from(&other.page_width);
237        self.highlight_timeout_ms
238            .merge_from(&other.highlight_timeout_ms);
239        self.snapshot_interval.merge_from(&other.snapshot_interval);
240        self.large_file_threshold_bytes
241            .merge_from(&other.large_file_threshold_bytes);
242        self.estimated_line_length
243            .merge_from(&other.estimated_line_length);
244        self.enable_inlay_hints
245            .merge_from(&other.enable_inlay_hints);
246        self.enable_semantic_tokens_full
247            .merge_from(&other.enable_semantic_tokens_full);
248        self.diagnostics_inline_text
249            .merge_from(&other.diagnostics_inline_text);
250        self.recovery_enabled.merge_from(&other.recovery_enabled);
251        self.auto_recovery_save_interval_secs
252            .merge_from(&other.auto_recovery_save_interval_secs);
253        self.auto_save_enabled.merge_from(&other.auto_save_enabled);
254        self.auto_save_interval_secs
255            .merge_from(&other.auto_save_interval_secs);
256        self.hot_exit.merge_from(&other.hot_exit);
257        self.confirm_quit.merge_from(&other.confirm_quit);
258        self.restore_previous_session
259            .merge_from(&other.restore_previous_session);
260        self.skip_session_restore_when_files_passed
261            .merge_from(&other.skip_session_restore_when_files_passed);
262        self.auto_create_empty_buffer_on_last_buffer_close
263            .merge_from(&other.auto_create_empty_buffer_on_last_buffer_close);
264        self.highlight_context_bytes
265            .merge_from(&other.highlight_context_bytes);
266        self.mouse_hover_enabled
267            .merge_from(&other.mouse_hover_enabled);
268        self.mouse_hover_delay_ms
269            .merge_from(&other.mouse_hover_delay_ms);
270        self.double_click_time_ms
271            .merge_from(&other.double_click_time_ms);
272        self.auto_revert_poll_interval_ms
273            .merge_from(&other.auto_revert_poll_interval_ms);
274        self.read_concurrency.merge_from(&other.read_concurrency);
275        self.file_tree_poll_interval_ms
276            .merge_from(&other.file_tree_poll_interval_ms);
277        self.default_line_ending
278            .merge_from(&other.default_line_ending);
279        self.trim_trailing_whitespace_on_save
280            .merge_from(&other.trim_trailing_whitespace_on_save);
281        self.ensure_final_newline_on_save
282            .merge_from(&other.ensure_final_newline_on_save);
283        self.highlight_matching_brackets
284            .merge_from(&other.highlight_matching_brackets);
285        self.rainbow_brackets.merge_from(&other.rainbow_brackets);
286        self.cursor_style.merge_from(&other.cursor_style);
287        self.keyboard_disambiguate_escape_codes
288            .merge_from(&other.keyboard_disambiguate_escape_codes);
289        self.keyboard_report_event_types
290            .merge_from(&other.keyboard_report_event_types);
291        self.keyboard_report_alternate_keys
292            .merge_from(&other.keyboard_report_alternate_keys);
293        self.keyboard_report_all_keys_as_escape_codes
294            .merge_from(&other.keyboard_report_all_keys_as_escape_codes);
295        self.completion_popup_auto_show
296            .merge_from(&other.completion_popup_auto_show);
297        self.quick_suggestions.merge_from(&other.quick_suggestions);
298        self.quick_suggestions_delay_ms
299            .merge_from(&other.quick_suggestions_delay_ms);
300        self.suggest_on_trigger_characters
301            .merge_from(&other.suggest_on_trigger_characters);
302        self.show_menu_bar.merge_from(&other.show_menu_bar);
303        self.menu_bar_mnemonics
304            .merge_from(&other.menu_bar_mnemonics);
305        self.show_tab_bar.merge_from(&other.show_tab_bar);
306        self.show_status_bar.merge_from(&other.show_status_bar);
307        if other.status_bar.is_some() {
308            self.status_bar = other.status_bar.clone();
309        }
310        self.show_prompt_line.merge_from(&other.show_prompt_line);
311        self.show_vertical_scrollbar
312            .merge_from(&other.show_vertical_scrollbar);
313        self.show_horizontal_scrollbar
314            .merge_from(&other.show_horizontal_scrollbar);
315        self.show_tilde.merge_from(&other.show_tilde);
316        self.use_terminal_bg.merge_from(&other.use_terminal_bg);
317        self.set_window_title.merge_from(&other.set_window_title);
318        self.rulers.merge_from(&other.rulers);
319        self.whitespace_show.merge_from(&other.whitespace_show);
320        self.whitespace_spaces_leading
321            .merge_from(&other.whitespace_spaces_leading);
322        self.whitespace_spaces_inner
323            .merge_from(&other.whitespace_spaces_inner);
324        self.whitespace_spaces_trailing
325            .merge_from(&other.whitespace_spaces_trailing);
326        self.whitespace_tabs_leading
327            .merge_from(&other.whitespace_tabs_leading);
328        self.whitespace_tabs_inner
329            .merge_from(&other.whitespace_tabs_inner);
330        self.whitespace_tabs_trailing
331            .merge_from(&other.whitespace_tabs_trailing);
332    }
333}
334
335/// Partial file explorer configuration.
336#[derive(Debug, Clone, Default, Deserialize, Serialize)]
337#[serde(default)]
338pub struct PartialFileExplorerConfig {
339    pub respect_gitignore: Option<bool>,
340    pub show_hidden: Option<bool>,
341    pub show_gitignored: Option<bool>,
342    pub custom_ignore_patterns: Option<Vec<String>>,
343    #[serde(
344        default,
345        deserialize_with = "crate::config::explorer_width::deserialize_optional"
346    )]
347    pub width: Option<crate::config::ExplorerWidth>,
348    pub preview_tabs: Option<bool>,
349    pub side: Option<crate::config::FileExplorerSide>,
350    pub auto_open_on_last_buffer_close: Option<bool>,
351    pub follow_active_buffer: Option<bool>,
352    pub compact_directories: Option<bool>,
353    pub tree_indicator_collapsed: Option<String>,
354    pub tree_indicator_expanded: Option<String>,
355}
356
357impl Merge for PartialFileExplorerConfig {
358    fn merge_from(&mut self, other: &Self) {
359        self.respect_gitignore.merge_from(&other.respect_gitignore);
360        self.show_hidden.merge_from(&other.show_hidden);
361        self.show_gitignored.merge_from(&other.show_gitignored);
362        self.custom_ignore_patterns
363            .merge_from(&other.custom_ignore_patterns);
364        self.width.merge_from(&other.width);
365        self.preview_tabs.merge_from(&other.preview_tabs);
366        self.side.merge_from(&other.side);
367        self.auto_open_on_last_buffer_close
368            .merge_from(&other.auto_open_on_last_buffer_close);
369        self.follow_active_buffer
370            .merge_from(&other.follow_active_buffer);
371        self.compact_directories
372            .merge_from(&other.compact_directories);
373        self.tree_indicator_collapsed
374            .merge_from(&other.tree_indicator_collapsed);
375        self.tree_indicator_expanded
376            .merge_from(&other.tree_indicator_expanded);
377    }
378}
379
380/// Partial file browser configuration.
381#[derive(Debug, Clone, Default, Deserialize, Serialize)]
382#[serde(default)]
383pub struct PartialFileBrowserConfig {
384    pub show_hidden: Option<bool>,
385}
386
387impl Merge for PartialFileBrowserConfig {
388    fn merge_from(&mut self, other: &Self) {
389        self.show_hidden.merge_from(&other.show_hidden);
390    }
391}
392
393/// Partial clipboard configuration.
394#[derive(Debug, Clone, Default, Deserialize, Serialize)]
395#[serde(default)]
396pub struct PartialClipboardConfig {
397    pub use_osc52: Option<bool>,
398    pub use_system_clipboard: Option<bool>,
399}
400
401impl Merge for PartialClipboardConfig {
402    fn merge_from(&mut self, other: &Self) {
403        self.use_osc52.merge_from(&other.use_osc52);
404        self.use_system_clipboard
405            .merge_from(&other.use_system_clipboard);
406    }
407}
408
409/// Partial terminal configuration.
410#[derive(Debug, Clone, Default, Deserialize, Serialize)]
411#[serde(default)]
412pub struct PartialTerminalConfig {
413    pub jump_to_end_on_output: Option<bool>,
414    pub shell: Option<crate::config::TerminalShellConfig>,
415}
416
417impl Merge for PartialTerminalConfig {
418    fn merge_from(&mut self, other: &Self) {
419        self.jump_to_end_on_output
420            .merge_from(&other.jump_to_end_on_output);
421        self.shell.merge_from(&other.shell);
422    }
423}
424
425/// Partial warnings configuration.
426#[derive(Debug, Clone, Default, Deserialize, Serialize)]
427#[serde(default)]
428pub struct PartialWarningsConfig {
429    pub show_status_indicator: Option<bool>,
430}
431
432impl Merge for PartialWarningsConfig {
433    fn merge_from(&mut self, other: &Self) {
434        self.show_status_indicator
435            .merge_from(&other.show_status_indicator);
436    }
437}
438
439/// Partial packages configuration for plugin/theme package management.
440#[derive(Debug, Clone, Default, Deserialize, Serialize)]
441#[serde(default)]
442pub struct PartialPackagesConfig {
443    pub sources: Option<Vec<String>>,
444}
445
446impl Merge for PartialPackagesConfig {
447    fn merge_from(&mut self, other: &Self) {
448        self.sources.merge_from(&other.sources);
449    }
450}
451
452/// Partial plugin configuration.
453#[derive(Debug, Clone, Default, Deserialize, Serialize)]
454#[serde(default)]
455pub struct PartialPluginConfig {
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub enabled: Option<bool>,
458    #[serde(skip_serializing_if = "Option::is_none")]
459    pub path: Option<std::path::PathBuf>,
460    /// Plugin-specific settings, shape defined by the plugin's schema sidecar.
461    /// Object values from lower layers are deep-merged on a key-by-key basis;
462    /// non-object values are replaced wholesale (matching how the layered
463    /// config docs describe "lists are replaced, objects are deep-merged").
464    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
465    pub settings: serde_json::Value,
466}
467
468fn merge_json_values(target: &mut serde_json::Value, other: &serde_json::Value) {
469    match (target, other) {
470        (serde_json::Value::Object(t_map), serde_json::Value::Object(o_map)) => {
471            for (k, v) in o_map {
472                match t_map.get_mut(k) {
473                    Some(existing) => merge_json_values(existing, v),
474                    None => {
475                        t_map.insert(k.clone(), v.clone());
476                    }
477                }
478            }
479        }
480        (t @ serde_json::Value::Null, o) if !o.is_null() => *t = o.clone(),
481        _ => {}
482    }
483}
484
485impl Merge for PartialPluginConfig {
486    fn merge_from(&mut self, other: &Self) {
487        self.enabled.merge_from(&other.enabled);
488        self.path.merge_from(&other.path);
489        merge_json_values(&mut self.settings, &other.settings);
490    }
491}
492
493/// Partial language configuration.
494#[derive(Debug, Clone, Default, Deserialize, Serialize)]
495#[serde(default)]
496pub struct PartialLanguageConfig {
497    pub extensions: Option<Vec<String>>,
498    pub filenames: Option<Vec<String>>,
499    pub grammar: Option<String>,
500    pub comment_prefix: Option<String>,
501    pub auto_indent: Option<bool>,
502    pub auto_close: Option<bool>,
503    pub auto_surround: Option<bool>,
504    pub textmate_grammar: Option<std::path::PathBuf>,
505    pub show_whitespace_tabs: Option<bool>,
506    pub line_wrap: Option<bool>,
507    pub wrap_column: Option<Option<usize>>,
508    pub page_view: Option<bool>,
509    pub page_width: Option<Option<usize>>,
510    pub use_tabs: Option<bool>,
511    pub tab_size: Option<usize>,
512    pub formatter: Option<FormatterConfig>,
513    pub format_on_save: Option<bool>,
514    pub on_save: Option<Vec<OnSaveAction>>,
515    pub word_characters: Option<Option<String>>,
516}
517
518impl Merge for PartialLanguageConfig {
519    fn merge_from(&mut self, other: &Self) {
520        self.extensions.merge_from(&other.extensions);
521        self.filenames.merge_from(&other.filenames);
522        self.grammar.merge_from(&other.grammar);
523        self.comment_prefix.merge_from(&other.comment_prefix);
524        self.auto_indent.merge_from(&other.auto_indent);
525        self.auto_close.merge_from(&other.auto_close);
526        self.auto_surround.merge_from(&other.auto_surround);
527        self.textmate_grammar.merge_from(&other.textmate_grammar);
528        self.show_whitespace_tabs
529            .merge_from(&other.show_whitespace_tabs);
530        self.line_wrap.merge_from(&other.line_wrap);
531        self.wrap_column.merge_from(&other.wrap_column);
532        self.page_view.merge_from(&other.page_view);
533        self.page_width.merge_from(&other.page_width);
534        self.use_tabs.merge_from(&other.use_tabs);
535        self.tab_size.merge_from(&other.tab_size);
536        self.formatter.merge_from(&other.formatter);
537        self.format_on_save.merge_from(&other.format_on_save);
538        self.on_save.merge_from(&other.on_save);
539        self.word_characters.merge_from(&other.word_characters);
540    }
541}
542
543// Conversion traits for resolving partial configs to concrete configs
544
545impl From<&crate::config::EditorConfig> for PartialEditorConfig {
546    fn from(cfg: &crate::config::EditorConfig) -> Self {
547        Self {
548            use_tabs: Some(cfg.use_tabs),
549            tab_size: Some(cfg.tab_size),
550            auto_indent: Some(cfg.auto_indent),
551            auto_close: Some(cfg.auto_close),
552            auto_surround: Some(cfg.auto_surround),
553            animations: Some(cfg.animations),
554            cursor_jump_animation: Some(cfg.cursor_jump_animation),
555            line_numbers: Some(cfg.line_numbers),
556            relative_line_numbers: Some(cfg.relative_line_numbers),
557            scroll_offset: Some(cfg.scroll_offset),
558            syntax_highlighting: Some(cfg.syntax_highlighting),
559            highlight_current_line: Some(cfg.highlight_current_line),
560            highlight_current_column: Some(cfg.highlight_current_column),
561            line_wrap: Some(cfg.line_wrap),
562            wrap_indent: Some(cfg.wrap_indent),
563            wrap_column: Some(cfg.wrap_column),
564            page_width: Some(cfg.page_width),
565            highlight_timeout_ms: Some(cfg.highlight_timeout_ms),
566            snapshot_interval: Some(cfg.snapshot_interval),
567            large_file_threshold_bytes: Some(cfg.large_file_threshold_bytes),
568            estimated_line_length: Some(cfg.estimated_line_length),
569            enable_inlay_hints: Some(cfg.enable_inlay_hints),
570            enable_semantic_tokens_full: Some(cfg.enable_semantic_tokens_full),
571            diagnostics_inline_text: Some(cfg.diagnostics_inline_text),
572            recovery_enabled: Some(cfg.recovery_enabled),
573            auto_recovery_save_interval_secs: Some(cfg.auto_recovery_save_interval_secs),
574            auto_save_enabled: Some(cfg.auto_save_enabled),
575            auto_save_interval_secs: Some(cfg.auto_save_interval_secs),
576            hot_exit: Some(cfg.hot_exit),
577            confirm_quit: Some(cfg.confirm_quit),
578            restore_previous_session: Some(cfg.restore_previous_session),
579            skip_session_restore_when_files_passed: Some(
580                cfg.skip_session_restore_when_files_passed,
581            ),
582            auto_create_empty_buffer_on_last_buffer_close: Some(
583                cfg.auto_create_empty_buffer_on_last_buffer_close,
584            ),
585            highlight_context_bytes: Some(cfg.highlight_context_bytes),
586            mouse_hover_enabled: Some(cfg.mouse_hover_enabled),
587            mouse_hover_delay_ms: Some(cfg.mouse_hover_delay_ms),
588            double_click_time_ms: Some(cfg.double_click_time_ms),
589            auto_revert_poll_interval_ms: Some(cfg.auto_revert_poll_interval_ms),
590            read_concurrency: Some(cfg.read_concurrency),
591            file_tree_poll_interval_ms: Some(cfg.file_tree_poll_interval_ms),
592            default_line_ending: Some(cfg.default_line_ending.clone()),
593            trim_trailing_whitespace_on_save: Some(cfg.trim_trailing_whitespace_on_save),
594            ensure_final_newline_on_save: Some(cfg.ensure_final_newline_on_save),
595            highlight_matching_brackets: Some(cfg.highlight_matching_brackets),
596            rainbow_brackets: Some(cfg.rainbow_brackets),
597            cursor_style: Some(cfg.cursor_style),
598            keyboard_disambiguate_escape_codes: Some(cfg.keyboard_disambiguate_escape_codes),
599            keyboard_report_event_types: Some(cfg.keyboard_report_event_types),
600            keyboard_report_alternate_keys: Some(cfg.keyboard_report_alternate_keys),
601            keyboard_report_all_keys_as_escape_codes: Some(
602                cfg.keyboard_report_all_keys_as_escape_codes,
603            ),
604            completion_popup_auto_show: Some(cfg.completion_popup_auto_show),
605            quick_suggestions: Some(cfg.quick_suggestions),
606            quick_suggestions_delay_ms: Some(cfg.quick_suggestions_delay_ms),
607            suggest_on_trigger_characters: Some(cfg.suggest_on_trigger_characters),
608            show_menu_bar: Some(cfg.show_menu_bar),
609            menu_bar_mnemonics: Some(cfg.menu_bar_mnemonics),
610            show_tab_bar: Some(cfg.show_tab_bar),
611            show_status_bar: Some(cfg.show_status_bar),
612            status_bar: Some(cfg.status_bar.clone()),
613            show_prompt_line: Some(cfg.show_prompt_line),
614            show_vertical_scrollbar: Some(cfg.show_vertical_scrollbar),
615            show_horizontal_scrollbar: Some(cfg.show_horizontal_scrollbar),
616            show_tilde: Some(cfg.show_tilde),
617            use_terminal_bg: Some(cfg.use_terminal_bg),
618            set_window_title: Some(cfg.set_window_title),
619            rulers: Some(cfg.rulers.clone()),
620            whitespace_show: Some(cfg.whitespace_show),
621            whitespace_spaces_leading: Some(cfg.whitespace_spaces_leading),
622            whitespace_spaces_inner: Some(cfg.whitespace_spaces_inner),
623            whitespace_spaces_trailing: Some(cfg.whitespace_spaces_trailing),
624            whitespace_tabs_leading: Some(cfg.whitespace_tabs_leading),
625            whitespace_tabs_inner: Some(cfg.whitespace_tabs_inner),
626            whitespace_tabs_trailing: Some(cfg.whitespace_tabs_trailing),
627        }
628    }
629}
630
631impl PartialEditorConfig {
632    /// Resolve this partial config to a concrete EditorConfig using defaults.
633    pub fn resolve(self, defaults: &crate::config::EditorConfig) -> crate::config::EditorConfig {
634        crate::config::EditorConfig {
635            use_tabs: self.use_tabs.unwrap_or(defaults.use_tabs),
636            tab_size: self.tab_size.unwrap_or(defaults.tab_size),
637            auto_indent: self.auto_indent.unwrap_or(defaults.auto_indent),
638            auto_close: self.auto_close.unwrap_or(defaults.auto_close),
639            auto_surround: self.auto_surround.unwrap_or(defaults.auto_surround),
640            animations: self.animations.unwrap_or(defaults.animations),
641            cursor_jump_animation: self
642                .cursor_jump_animation
643                .unwrap_or(defaults.cursor_jump_animation),
644            line_numbers: self.line_numbers.unwrap_or(defaults.line_numbers),
645            relative_line_numbers: self
646                .relative_line_numbers
647                .unwrap_or(defaults.relative_line_numbers),
648            scroll_offset: self.scroll_offset.unwrap_or(defaults.scroll_offset),
649            syntax_highlighting: self
650                .syntax_highlighting
651                .unwrap_or(defaults.syntax_highlighting),
652            highlight_current_line: self
653                .highlight_current_line
654                .unwrap_or(defaults.highlight_current_line),
655            highlight_current_column: self
656                .highlight_current_column
657                .unwrap_or(defaults.highlight_current_column),
658            line_wrap: self.line_wrap.unwrap_or(defaults.line_wrap),
659            wrap_indent: self.wrap_indent.unwrap_or(defaults.wrap_indent),
660            wrap_column: self.wrap_column.unwrap_or(defaults.wrap_column),
661            page_width: self.page_width.unwrap_or(defaults.page_width),
662            highlight_timeout_ms: self
663                .highlight_timeout_ms
664                .unwrap_or(defaults.highlight_timeout_ms),
665            snapshot_interval: self.snapshot_interval.unwrap_or(defaults.snapshot_interval),
666            large_file_threshold_bytes: self
667                .large_file_threshold_bytes
668                .unwrap_or(defaults.large_file_threshold_bytes),
669            estimated_line_length: self
670                .estimated_line_length
671                .unwrap_or(defaults.estimated_line_length),
672            enable_inlay_hints: self
673                .enable_inlay_hints
674                .unwrap_or(defaults.enable_inlay_hints),
675            enable_semantic_tokens_full: self
676                .enable_semantic_tokens_full
677                .unwrap_or(defaults.enable_semantic_tokens_full),
678            diagnostics_inline_text: self
679                .diagnostics_inline_text
680                .unwrap_or(defaults.diagnostics_inline_text),
681            recovery_enabled: self.recovery_enabled.unwrap_or(defaults.recovery_enabled),
682            auto_recovery_save_interval_secs: self
683                .auto_recovery_save_interval_secs
684                .unwrap_or(defaults.auto_recovery_save_interval_secs),
685            auto_save_enabled: self.auto_save_enabled.unwrap_or(defaults.auto_save_enabled),
686            auto_save_interval_secs: self
687                .auto_save_interval_secs
688                .unwrap_or(defaults.auto_save_interval_secs),
689            hot_exit: self.hot_exit.unwrap_or(defaults.hot_exit),
690            confirm_quit: self.confirm_quit.unwrap_or(defaults.confirm_quit),
691            restore_previous_session: self
692                .restore_previous_session
693                .unwrap_or(defaults.restore_previous_session),
694            skip_session_restore_when_files_passed: self
695                .skip_session_restore_when_files_passed
696                .unwrap_or(defaults.skip_session_restore_when_files_passed),
697            auto_create_empty_buffer_on_last_buffer_close: self
698                .auto_create_empty_buffer_on_last_buffer_close
699                .unwrap_or(defaults.auto_create_empty_buffer_on_last_buffer_close),
700            highlight_context_bytes: self
701                .highlight_context_bytes
702                .unwrap_or(defaults.highlight_context_bytes),
703            mouse_hover_enabled: self
704                .mouse_hover_enabled
705                .unwrap_or(defaults.mouse_hover_enabled),
706            mouse_hover_delay_ms: self
707                .mouse_hover_delay_ms
708                .unwrap_or(defaults.mouse_hover_delay_ms),
709            double_click_time_ms: self
710                .double_click_time_ms
711                .unwrap_or(defaults.double_click_time_ms),
712            auto_revert_poll_interval_ms: self
713                .auto_revert_poll_interval_ms
714                .unwrap_or(defaults.auto_revert_poll_interval_ms),
715            read_concurrency: self.read_concurrency.unwrap_or(defaults.read_concurrency),
716            file_tree_poll_interval_ms: self
717                .file_tree_poll_interval_ms
718                .unwrap_or(defaults.file_tree_poll_interval_ms),
719            default_line_ending: self
720                .default_line_ending
721                .unwrap_or(defaults.default_line_ending.clone()),
722            trim_trailing_whitespace_on_save: self
723                .trim_trailing_whitespace_on_save
724                .unwrap_or(defaults.trim_trailing_whitespace_on_save),
725            ensure_final_newline_on_save: self
726                .ensure_final_newline_on_save
727                .unwrap_or(defaults.ensure_final_newline_on_save),
728            highlight_matching_brackets: self
729                .highlight_matching_brackets
730                .unwrap_or(defaults.highlight_matching_brackets),
731            rainbow_brackets: self.rainbow_brackets.unwrap_or(defaults.rainbow_brackets),
732            cursor_style: self.cursor_style.unwrap_or(defaults.cursor_style),
733            keyboard_disambiguate_escape_codes: self
734                .keyboard_disambiguate_escape_codes
735                .unwrap_or(defaults.keyboard_disambiguate_escape_codes),
736            keyboard_report_event_types: self
737                .keyboard_report_event_types
738                .unwrap_or(defaults.keyboard_report_event_types),
739            keyboard_report_alternate_keys: self
740                .keyboard_report_alternate_keys
741                .unwrap_or(defaults.keyboard_report_alternate_keys),
742            keyboard_report_all_keys_as_escape_codes: self
743                .keyboard_report_all_keys_as_escape_codes
744                .unwrap_or(defaults.keyboard_report_all_keys_as_escape_codes),
745            completion_popup_auto_show: self
746                .completion_popup_auto_show
747                .unwrap_or(defaults.completion_popup_auto_show),
748            quick_suggestions: self.quick_suggestions.unwrap_or(defaults.quick_suggestions),
749            quick_suggestions_delay_ms: self
750                .quick_suggestions_delay_ms
751                .unwrap_or(defaults.quick_suggestions_delay_ms),
752            suggest_on_trigger_characters: self
753                .suggest_on_trigger_characters
754                .unwrap_or(defaults.suggest_on_trigger_characters),
755            show_menu_bar: self.show_menu_bar.unwrap_or(defaults.show_menu_bar),
756            menu_bar_mnemonics: self
757                .menu_bar_mnemonics
758                .unwrap_or(defaults.menu_bar_mnemonics),
759            show_tab_bar: self.show_tab_bar.unwrap_or(defaults.show_tab_bar),
760            show_status_bar: self.show_status_bar.unwrap_or(defaults.show_status_bar),
761            status_bar: self
762                .status_bar
763                .unwrap_or_else(|| defaults.status_bar.clone()),
764            show_prompt_line: self.show_prompt_line.unwrap_or(defaults.show_prompt_line),
765            show_vertical_scrollbar: self
766                .show_vertical_scrollbar
767                .unwrap_or(defaults.show_vertical_scrollbar),
768            show_horizontal_scrollbar: self
769                .show_horizontal_scrollbar
770                .unwrap_or(defaults.show_horizontal_scrollbar),
771            show_tilde: self.show_tilde.unwrap_or(defaults.show_tilde),
772            use_terminal_bg: self.use_terminal_bg.unwrap_or(defaults.use_terminal_bg),
773            set_window_title: self.set_window_title.unwrap_or(defaults.set_window_title),
774            rulers: self.rulers.unwrap_or_else(|| defaults.rulers.clone()),
775            whitespace_show: self.whitespace_show.unwrap_or(defaults.whitespace_show),
776            whitespace_spaces_leading: self
777                .whitespace_spaces_leading
778                .unwrap_or(defaults.whitespace_spaces_leading),
779            whitespace_spaces_inner: self
780                .whitespace_spaces_inner
781                .unwrap_or(defaults.whitespace_spaces_inner),
782            whitespace_spaces_trailing: self
783                .whitespace_spaces_trailing
784                .unwrap_or(defaults.whitespace_spaces_trailing),
785            whitespace_tabs_leading: self
786                .whitespace_tabs_leading
787                .unwrap_or(defaults.whitespace_tabs_leading),
788            whitespace_tabs_inner: self
789                .whitespace_tabs_inner
790                .unwrap_or(defaults.whitespace_tabs_inner),
791            whitespace_tabs_trailing: self
792                .whitespace_tabs_trailing
793                .unwrap_or(defaults.whitespace_tabs_trailing),
794        }
795    }
796}
797
798impl From<&FileExplorerConfig> for PartialFileExplorerConfig {
799    fn from(cfg: &FileExplorerConfig) -> Self {
800        Self {
801            respect_gitignore: Some(cfg.respect_gitignore),
802            show_hidden: Some(cfg.show_hidden),
803            show_gitignored: Some(cfg.show_gitignored),
804            custom_ignore_patterns: Some(cfg.custom_ignore_patterns.clone()),
805            width: Some(cfg.width),
806            preview_tabs: Some(cfg.preview_tabs),
807            side: Some(cfg.side),
808            auto_open_on_last_buffer_close: Some(cfg.auto_open_on_last_buffer_close),
809            follow_active_buffer: Some(cfg.follow_active_buffer),
810            compact_directories: Some(cfg.compact_directories),
811            tree_indicator_collapsed: Some(cfg.tree_indicator_collapsed.clone()),
812            tree_indicator_expanded: Some(cfg.tree_indicator_expanded.clone()),
813        }
814    }
815}
816
817impl PartialFileExplorerConfig {
818    pub fn resolve(self, defaults: &FileExplorerConfig) -> FileExplorerConfig {
819        FileExplorerConfig {
820            respect_gitignore: self.respect_gitignore.unwrap_or(defaults.respect_gitignore),
821            show_hidden: self.show_hidden.unwrap_or(defaults.show_hidden),
822            show_gitignored: self.show_gitignored.unwrap_or(defaults.show_gitignored),
823            custom_ignore_patterns: self
824                .custom_ignore_patterns
825                .unwrap_or_else(|| defaults.custom_ignore_patterns.clone()),
826            width: self.width.unwrap_or(defaults.width),
827            preview_tabs: self.preview_tabs.unwrap_or(defaults.preview_tabs),
828            side: self.side.unwrap_or(defaults.side),
829            auto_open_on_last_buffer_close: self
830                .auto_open_on_last_buffer_close
831                .unwrap_or(defaults.auto_open_on_last_buffer_close),
832            follow_active_buffer: self
833                .follow_active_buffer
834                .unwrap_or(defaults.follow_active_buffer),
835            compact_directories: self
836                .compact_directories
837                .unwrap_or(defaults.compact_directories),
838            tree_indicator_collapsed: self
839                .tree_indicator_collapsed
840                .unwrap_or_else(|| defaults.tree_indicator_collapsed.clone()),
841            tree_indicator_expanded: self
842                .tree_indicator_expanded
843                .unwrap_or_else(|| defaults.tree_indicator_expanded.clone()),
844        }
845    }
846}
847
848impl From<&FileBrowserConfig> for PartialFileBrowserConfig {
849    fn from(cfg: &FileBrowserConfig) -> Self {
850        Self {
851            show_hidden: Some(cfg.show_hidden),
852        }
853    }
854}
855
856impl PartialFileBrowserConfig {
857    pub fn resolve(self, defaults: &FileBrowserConfig) -> FileBrowserConfig {
858        FileBrowserConfig {
859            show_hidden: self.show_hidden.unwrap_or(defaults.show_hidden),
860        }
861    }
862}
863
864impl From<&ClipboardConfig> for PartialClipboardConfig {
865    fn from(cfg: &ClipboardConfig) -> Self {
866        Self {
867            use_osc52: Some(cfg.use_osc52),
868            use_system_clipboard: Some(cfg.use_system_clipboard),
869        }
870    }
871}
872
873impl PartialClipboardConfig {
874    pub fn resolve(self, defaults: &ClipboardConfig) -> ClipboardConfig {
875        ClipboardConfig {
876            use_osc52: self.use_osc52.unwrap_or(defaults.use_osc52),
877            use_system_clipboard: self
878                .use_system_clipboard
879                .unwrap_or(defaults.use_system_clipboard),
880        }
881    }
882}
883
884impl From<&TerminalConfig> for PartialTerminalConfig {
885    fn from(cfg: &TerminalConfig) -> Self {
886        Self {
887            jump_to_end_on_output: Some(cfg.jump_to_end_on_output),
888            shell: cfg.shell.clone(),
889        }
890    }
891}
892
893impl PartialTerminalConfig {
894    pub fn resolve(self, defaults: &TerminalConfig) -> TerminalConfig {
895        TerminalConfig {
896            jump_to_end_on_output: self
897                .jump_to_end_on_output
898                .unwrap_or(defaults.jump_to_end_on_output),
899            shell: self.shell.or_else(|| defaults.shell.clone()),
900        }
901    }
902}
903
904impl From<&WarningsConfig> for PartialWarningsConfig {
905    fn from(cfg: &WarningsConfig) -> Self {
906        Self {
907            show_status_indicator: Some(cfg.show_status_indicator),
908        }
909    }
910}
911
912impl PartialWarningsConfig {
913    pub fn resolve(self, defaults: &WarningsConfig) -> WarningsConfig {
914        WarningsConfig {
915            show_status_indicator: self
916                .show_status_indicator
917                .unwrap_or(defaults.show_status_indicator),
918        }
919    }
920}
921
922impl From<&crate::config::PackagesConfig> for PartialPackagesConfig {
923    fn from(cfg: &crate::config::PackagesConfig) -> Self {
924        Self {
925            sources: Some(cfg.sources.clone()),
926        }
927    }
928}
929
930impl PartialPackagesConfig {
931    pub fn resolve(
932        self,
933        defaults: &crate::config::PackagesConfig,
934    ) -> crate::config::PackagesConfig {
935        crate::config::PackagesConfig {
936            sources: self.sources.unwrap_or_else(|| defaults.sources.clone()),
937        }
938    }
939}
940
941impl From<&PluginConfig> for PartialPluginConfig {
942    fn from(cfg: &PluginConfig) -> Self {
943        Self {
944            enabled: Some(cfg.enabled),
945            path: cfg.path.clone(),
946            settings: cfg.settings.clone(),
947        }
948    }
949}
950
951impl PartialPluginConfig {
952    pub fn resolve(self, defaults: &PluginConfig) -> PluginConfig {
953        let mut settings = self.settings;
954        if settings.is_null() {
955            settings = defaults.settings.clone();
956        }
957        PluginConfig {
958            enabled: self.enabled.unwrap_or(defaults.enabled),
959            path: self.path.or_else(|| defaults.path.clone()),
960            settings,
961        }
962    }
963}
964
965impl From<&LanguageConfig> for PartialLanguageConfig {
966    fn from(cfg: &LanguageConfig) -> Self {
967        Self {
968            extensions: Some(cfg.extensions.clone()),
969            filenames: Some(cfg.filenames.clone()),
970            grammar: Some(cfg.grammar.clone()),
971            comment_prefix: cfg.comment_prefix.clone(),
972            auto_indent: Some(cfg.auto_indent),
973            auto_close: cfg.auto_close,
974            auto_surround: cfg.auto_surround,
975            textmate_grammar: cfg.textmate_grammar.clone(),
976            show_whitespace_tabs: Some(cfg.show_whitespace_tabs),
977            line_wrap: cfg.line_wrap,
978            wrap_column: Some(cfg.wrap_column),
979            page_view: cfg.page_view,
980            page_width: Some(cfg.page_width),
981            use_tabs: cfg.use_tabs,
982            tab_size: cfg.tab_size,
983            formatter: cfg.formatter.clone(),
984            format_on_save: Some(cfg.format_on_save),
985            on_save: Some(cfg.on_save.clone()),
986            word_characters: Some(cfg.word_characters.clone()),
987        }
988    }
989}
990
991impl PartialLanguageConfig {
992    pub fn resolve(self, defaults: &LanguageConfig) -> LanguageConfig {
993        LanguageConfig {
994            extensions: self
995                .extensions
996                .unwrap_or_else(|| defaults.extensions.clone()),
997            filenames: self.filenames.unwrap_or_else(|| defaults.filenames.clone()),
998            grammar: self.grammar.unwrap_or_else(|| defaults.grammar.clone()),
999            comment_prefix: self
1000                .comment_prefix
1001                .or_else(|| defaults.comment_prefix.clone()),
1002            auto_indent: self.auto_indent.unwrap_or(defaults.auto_indent),
1003            auto_close: self.auto_close.or(defaults.auto_close),
1004            auto_surround: self.auto_surround.or(defaults.auto_surround),
1005            textmate_grammar: self
1006                .textmate_grammar
1007                .or_else(|| defaults.textmate_grammar.clone()),
1008            show_whitespace_tabs: self
1009                .show_whitespace_tabs
1010                .unwrap_or(defaults.show_whitespace_tabs),
1011            line_wrap: self.line_wrap.or(defaults.line_wrap),
1012            wrap_column: self.wrap_column.unwrap_or(defaults.wrap_column),
1013            page_view: self.page_view.or(defaults.page_view),
1014            page_width: self.page_width.unwrap_or(defaults.page_width),
1015            use_tabs: self.use_tabs.or(defaults.use_tabs),
1016            tab_size: self.tab_size.or(defaults.tab_size),
1017            formatter: self.formatter.or_else(|| defaults.formatter.clone()),
1018            format_on_save: self.format_on_save.unwrap_or(defaults.format_on_save),
1019            on_save: self.on_save.unwrap_or_else(|| defaults.on_save.clone()),
1020            word_characters: self
1021                .word_characters
1022                .unwrap_or_else(|| defaults.word_characters.clone()),
1023        }
1024    }
1025}
1026
1027impl From<&crate::config::Config> for PartialConfig {
1028    fn from(cfg: &crate::config::Config) -> Self {
1029        Self {
1030            version: Some(cfg.version),
1031            theme: Some(cfg.theme.clone()),
1032            locale: cfg.locale.0.clone(),
1033            check_for_updates: Some(cfg.check_for_updates),
1034            editor: Some(PartialEditorConfig::from(&cfg.editor)),
1035            file_explorer: Some(PartialFileExplorerConfig::from(&cfg.file_explorer)),
1036            file_browser: Some(PartialFileBrowserConfig::from(&cfg.file_browser)),
1037            clipboard: Some(PartialClipboardConfig::from(&cfg.clipboard)),
1038            terminal: Some(PartialTerminalConfig::from(&cfg.terminal)),
1039            keybindings: Some(cfg.keybindings.clone()),
1040            keybinding_maps: Some(cfg.keybinding_maps.clone()),
1041            active_keybinding_map: Some(cfg.active_keybinding_map.clone()),
1042            languages: Some(
1043                cfg.languages
1044                    .iter()
1045                    .map(|(k, v)| (k.clone(), PartialLanguageConfig::from(v)))
1046                    .collect(),
1047            ),
1048            default_language: cfg.default_language.clone(),
1049            lsp: Some(
1050                cfg.lsp
1051                    .iter()
1052                    .map(|(k, v)| {
1053                        // Normalize to Single for 1-element arrays so that
1054                        // json_diff can compare object fields recursively
1055                        // (arrays are compared wholesale, not element-wise).
1056                        let lang_config = match v {
1057                            LspLanguageConfig::Multi(vec) if vec.len() == 1 => {
1058                                LspLanguageConfig::Single(Box::new(vec[0].clone()))
1059                            }
1060                            other => other.clone(),
1061                        };
1062                        (k.clone(), lang_config)
1063                    })
1064                    .collect(),
1065            ),
1066            universal_lsp: Some(
1067                cfg.universal_lsp
1068                    .iter()
1069                    .map(|(k, v)| {
1070                        let lang_config = match v {
1071                            LspLanguageConfig::Multi(vec) if vec.len() == 1 => {
1072                                LspLanguageConfig::Single(Box::new(vec[0].clone()))
1073                            }
1074                            other => other.clone(),
1075                        };
1076                        (k.clone(), lang_config)
1077                    })
1078                    .collect(),
1079            ),
1080            warnings: Some(PartialWarningsConfig::from(&cfg.warnings)),
1081            // Only include plugins that differ from defaults
1082            // Path is auto-discovered at runtime and should never be saved
1083            plugins: {
1084                let default_plugin = crate::config::PluginConfig::default();
1085                let non_default_plugins: HashMap<String, PartialPluginConfig> = cfg
1086                    .plugins
1087                    .iter()
1088                    .filter(|(_, v)| {
1089                        let settings_changed = match &v.settings {
1090                            serde_json::Value::Null => false,
1091                            serde_json::Value::Object(o) => !o.is_empty(),
1092                            _ => true,
1093                        };
1094                        v.enabled != default_plugin.enabled || settings_changed
1095                    })
1096                    .map(|(k, v)| {
1097                        (
1098                            k.clone(),
1099                            PartialPluginConfig {
1100                                enabled: Some(v.enabled),
1101                                path: None, // Don't save path - it's auto-discovered
1102                                settings: v.settings.clone(),
1103                            },
1104                        )
1105                    })
1106                    .collect();
1107                if non_default_plugins.is_empty() {
1108                    None
1109                } else {
1110                    Some(non_default_plugins)
1111                }
1112            },
1113            packages: Some(PartialPackagesConfig::from(&cfg.packages)),
1114        }
1115    }
1116}
1117
1118impl PartialConfig {
1119    /// Resolve this partial config to a concrete Config using system defaults.
1120    pub fn resolve(self) -> crate::config::Config {
1121        let defaults = crate::config::Config::default();
1122        self.resolve_with_defaults(&defaults)
1123    }
1124
1125    /// Resolve this partial config to a concrete Config using provided defaults.
1126    pub fn resolve_with_defaults(self, defaults: &crate::config::Config) -> crate::config::Config {
1127        // Resolve languages HashMap - merge with defaults
1128        let languages = {
1129            let mut result = defaults.languages.clone();
1130            if let Some(partial_langs) = self.languages {
1131                for (key, partial_lang) in partial_langs {
1132                    let default_lang = result.get(&key).cloned().unwrap_or_default();
1133                    result.insert(key, partial_lang.resolve(&default_lang));
1134                }
1135            }
1136            result
1137        };
1138
1139        // Resolve lsp HashMap - merge with defaults
1140        // Each language can have one or more server configs.
1141        // User config (LspLanguageConfig) can be a single object or an array.
1142        let lsp = {
1143            let mut result = defaults.lsp.clone();
1144            if let Some(partial_lsp) = self.lsp {
1145                for (key, lang_config) in partial_lsp {
1146                    let user_configs = lang_config.into_vec();
1147                    if let Some(default_configs) = result.get(&key) {
1148                        let default_slice = default_configs.as_slice();
1149                        // For single-server user config, merge with the first default.
1150                        // For multi-server user config, replace entirely (user is
1151                        // explicitly configuring the full server list).
1152                        if user_configs.len() == 1 && default_slice.len() == 1 {
1153                            let merged = user_configs
1154                                .into_iter()
1155                                .next()
1156                                .unwrap()
1157                                .merge_with_defaults(&default_slice[0]);
1158                            result.insert(key, LspLanguageConfig::Multi(vec![merged]));
1159                        } else {
1160                            result.insert(key, LspLanguageConfig::Multi(user_configs));
1161                        }
1162                    } else {
1163                        // New language not in defaults - use as-is
1164                        result.insert(key, LspLanguageConfig::Multi(user_configs));
1165                    }
1166                }
1167            }
1168            result
1169        };
1170
1171        // Resolve universal_lsp HashMap - same merge strategy as lsp
1172        let universal_lsp = {
1173            let mut result = defaults.universal_lsp.clone();
1174            if let Some(partial_universal_lsp) = self.universal_lsp {
1175                for (key, lang_config) in partial_universal_lsp {
1176                    let user_configs = lang_config.into_vec();
1177                    if let Some(default_configs) = result.get(&key) {
1178                        let default_slice = default_configs.as_slice();
1179                        if user_configs.len() == 1 && default_slice.len() == 1 {
1180                            let merged = user_configs
1181                                .into_iter()
1182                                .next()
1183                                .unwrap()
1184                                .merge_with_defaults(&default_slice[0]);
1185                            result.insert(key, LspLanguageConfig::Multi(vec![merged]));
1186                        } else {
1187                            result.insert(key, LspLanguageConfig::Multi(user_configs));
1188                        }
1189                    } else {
1190                        result.insert(key, LspLanguageConfig::Multi(user_configs));
1191                    }
1192                }
1193            }
1194            result
1195        };
1196
1197        // Resolve keybinding_maps HashMap - merge with defaults
1198        let keybinding_maps = {
1199            let mut result = defaults.keybinding_maps.clone();
1200            if let Some(partial_maps) = self.keybinding_maps {
1201                for (key, config) in partial_maps {
1202                    result.insert(key, config);
1203                }
1204            }
1205            result
1206        };
1207
1208        // Resolve plugins HashMap - merge with defaults
1209        let plugins = {
1210            let mut result = defaults.plugins.clone();
1211            if let Some(partial_plugins) = self.plugins {
1212                for (key, partial_plugin) in partial_plugins {
1213                    let default_plugin = result.get(&key).cloned().unwrap_or_default();
1214                    result.insert(key, partial_plugin.resolve(&default_plugin));
1215                }
1216            }
1217            result
1218        };
1219
1220        crate::config::Config {
1221            version: self.version.unwrap_or(defaults.version),
1222            theme: self.theme.unwrap_or_else(|| defaults.theme.clone()),
1223            locale: crate::config::LocaleName::from(
1224                self.locale.or_else(|| defaults.locale.0.clone()),
1225            ),
1226            check_for_updates: self.check_for_updates.unwrap_or(defaults.check_for_updates),
1227            editor: self
1228                .editor
1229                .map(|e| e.resolve(&defaults.editor))
1230                .unwrap_or_else(|| defaults.editor.clone()),
1231            file_explorer: self
1232                .file_explorer
1233                .map(|e| e.resolve(&defaults.file_explorer))
1234                .unwrap_or_else(|| defaults.file_explorer.clone()),
1235            file_browser: self
1236                .file_browser
1237                .map(|e| e.resolve(&defaults.file_browser))
1238                .unwrap_or_else(|| defaults.file_browser.clone()),
1239            clipboard: self
1240                .clipboard
1241                .map(|e| e.resolve(&defaults.clipboard))
1242                .unwrap_or_else(|| defaults.clipboard.clone()),
1243            terminal: self
1244                .terminal
1245                .map(|e| e.resolve(&defaults.terminal))
1246                .unwrap_or_else(|| defaults.terminal.clone()),
1247            keybindings: self
1248                .keybindings
1249                .unwrap_or_else(|| defaults.keybindings.clone()),
1250            keybinding_maps,
1251            active_keybinding_map: self
1252                .active_keybinding_map
1253                .unwrap_or_else(|| defaults.active_keybinding_map.clone()),
1254            languages,
1255            default_language: self
1256                .default_language
1257                .or_else(|| defaults.default_language.clone()),
1258            lsp,
1259            universal_lsp,
1260            warnings: self
1261                .warnings
1262                .map(|e| e.resolve(&defaults.warnings))
1263                .unwrap_or_else(|| defaults.warnings.clone()),
1264            plugins,
1265            packages: self
1266                .packages
1267                .map(|e| e.resolve(&defaults.packages))
1268                .unwrap_or_else(|| defaults.packages.clone()),
1269        }
1270    }
1271}
1272
1273// Default implementation for LanguageConfig to support merge_hashmap_recursive
1274impl Default for LanguageConfig {
1275    fn default() -> Self {
1276        Self {
1277            extensions: Vec::new(),
1278            filenames: Vec::new(),
1279            grammar: String::new(),
1280            comment_prefix: None,
1281            auto_indent: true,
1282            auto_close: None,
1283            auto_surround: None,
1284            textmate_grammar: None,
1285            show_whitespace_tabs: true,
1286            line_wrap: None,
1287            wrap_column: None,
1288            page_view: None,
1289            page_width: None,
1290            use_tabs: None,
1291            tab_size: None,
1292            formatter: None,
1293            format_on_save: false,
1294            on_save: Vec::new(),
1295            word_characters: None,
1296        }
1297    }
1298}
1299
1300/// Session-specific configuration for runtime/volatile overrides.
1301///
1302/// This struct represents the session layer of the config hierarchy - settings
1303/// that are temporary and may not persist across editor restarts.
1304///
1305/// Unlike PartialConfig, SessionConfig provides a focused API for common
1306/// runtime modifications like temporary theme switching.
1307#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1308#[serde(default)]
1309pub struct SessionConfig {
1310    /// Temporarily override the theme (e.g., for preview)
1311    pub theme: Option<ThemeName>,
1312
1313    /// Temporary editor overrides (e.g., changing tab_size for current session)
1314    pub editor: Option<PartialEditorConfig>,
1315
1316    /// Buffer-specific overrides keyed by absolute file path.
1317    /// These allow per-file settings that persist only during the session.
1318    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
1319    pub buffer_overrides: HashMap<std::path::PathBuf, PartialEditorConfig>,
1320}
1321
1322impl SessionConfig {
1323    /// Create a new empty session config.
1324    pub fn new() -> Self {
1325        Self::default()
1326    }
1327
1328    /// Set a temporary theme override.
1329    pub fn set_theme(&mut self, theme: ThemeName) {
1330        self.theme = Some(theme);
1331    }
1332
1333    /// Clear the theme override, reverting to lower layers.
1334    pub fn clear_theme(&mut self) {
1335        self.theme = None;
1336    }
1337
1338    /// Set an editor setting for the current session.
1339    pub fn set_editor_option<F>(&mut self, setter: F)
1340    where
1341        F: FnOnce(&mut PartialEditorConfig),
1342    {
1343        let editor = self.editor.get_or_insert_with(Default::default);
1344        setter(editor);
1345    }
1346
1347    /// Set a buffer-specific editor override.
1348    pub fn set_buffer_override(&mut self, path: std::path::PathBuf, config: PartialEditorConfig) {
1349        self.buffer_overrides.insert(path, config);
1350    }
1351
1352    /// Clear buffer-specific overrides for a path.
1353    pub fn clear_buffer_override(&mut self, path: &std::path::Path) {
1354        self.buffer_overrides.remove(path);
1355    }
1356
1357    /// Get buffer-specific editor config if set.
1358    pub fn get_buffer_override(&self, path: &std::path::Path) -> Option<&PartialEditorConfig> {
1359        self.buffer_overrides.get(path)
1360    }
1361
1362    /// Convert to a PartialConfig for merging with other layers.
1363    pub fn to_partial_config(&self) -> PartialConfig {
1364        PartialConfig {
1365            theme: self.theme.clone(),
1366            editor: self.editor.clone(),
1367            ..Default::default()
1368        }
1369    }
1370
1371    /// Check if this session config has any values set.
1372    pub fn is_empty(&self) -> bool {
1373        self.theme.is_none() && self.editor.is_none() && self.buffer_overrides.is_empty()
1374    }
1375}
1376
1377impl From<PartialConfig> for SessionConfig {
1378    fn from(partial: PartialConfig) -> Self {
1379        Self {
1380            theme: partial.theme,
1381            editor: partial.editor,
1382            buffer_overrides: HashMap::new(),
1383        }
1384    }
1385}
1386
1387#[cfg(test)]
1388mod tests {
1389    use super::*;
1390
1391    #[test]
1392    fn merge_option_higher_precedence_wins() {
1393        let mut higher: Option<i32> = Some(10);
1394        let lower: Option<i32> = Some(5);
1395        higher.merge_from(&lower);
1396        assert_eq!(higher, Some(10));
1397    }
1398
1399    #[test]
1400    fn merge_option_fills_from_lower_when_none() {
1401        let mut higher: Option<i32> = None;
1402        let lower: Option<i32> = Some(5);
1403        higher.merge_from(&lower);
1404        assert_eq!(higher, Some(5));
1405    }
1406
1407    #[test]
1408    fn merge_editor_config_recursive() {
1409        let mut higher = PartialEditorConfig {
1410            tab_size: Some(2),
1411            ..Default::default()
1412        };
1413        let lower = PartialEditorConfig {
1414            tab_size: Some(4),
1415            line_numbers: Some(true),
1416            ..Default::default()
1417        };
1418
1419        higher.merge_from(&lower);
1420
1421        assert_eq!(higher.tab_size, Some(2)); // Higher wins
1422        assert_eq!(higher.line_numbers, Some(true)); // Filled from lower
1423    }
1424
1425    #[test]
1426    fn merge_partial_config_combines_languages() {
1427        let mut higher = PartialConfig {
1428            languages: Some(HashMap::from([(
1429                "rust".to_string(),
1430                PartialLanguageConfig {
1431                    tab_size: Some(4),
1432                    ..Default::default()
1433                },
1434            )])),
1435            ..Default::default()
1436        };
1437        let lower = PartialConfig {
1438            languages: Some(HashMap::from([(
1439                "python".to_string(),
1440                PartialLanguageConfig {
1441                    tab_size: Some(4),
1442                    ..Default::default()
1443                },
1444            )])),
1445            ..Default::default()
1446        };
1447
1448        higher.merge_from(&lower);
1449
1450        let langs = higher.languages.unwrap();
1451        assert!(langs.contains_key("rust"));
1452        assert!(langs.contains_key("python"));
1453    }
1454
1455    #[test]
1456    fn merge_languages_same_key_higher_wins() {
1457        let mut higher = PartialConfig {
1458            languages: Some(HashMap::from([(
1459                "rust".to_string(),
1460                PartialLanguageConfig {
1461                    tab_size: Some(2),
1462                    use_tabs: Some(true),
1463                    ..Default::default()
1464                },
1465            )])),
1466            ..Default::default()
1467        };
1468        let lower = PartialConfig {
1469            languages: Some(HashMap::from([(
1470                "rust".to_string(),
1471                PartialLanguageConfig {
1472                    tab_size: Some(4),
1473                    auto_indent: Some(false),
1474                    ..Default::default()
1475                },
1476            )])),
1477            ..Default::default()
1478        };
1479
1480        higher.merge_from(&lower);
1481
1482        let langs = higher.languages.unwrap();
1483        let rust = langs.get("rust").unwrap();
1484        assert_eq!(rust.tab_size, Some(2)); // Higher wins
1485        assert_eq!(rust.use_tabs, Some(true)); // From higher
1486        assert_eq!(rust.auto_indent, Some(false)); // Filled from lower
1487    }
1488
1489    #[test]
1490    fn resolve_fills_defaults() {
1491        let partial = PartialConfig {
1492            theme: Some(ThemeName::from("dark")),
1493            ..Default::default()
1494        };
1495
1496        let resolved = partial.resolve();
1497
1498        assert_eq!(resolved.theme.0, "dark");
1499        assert_eq!(resolved.editor.tab_size, 4); // Default
1500        assert!(resolved.editor.line_numbers); // Default true
1501    }
1502
1503    #[test]
1504    fn resolve_preserves_set_values() {
1505        let partial = PartialConfig {
1506            editor: Some(PartialEditorConfig {
1507                tab_size: Some(2),
1508                line_numbers: Some(false),
1509                ..Default::default()
1510            }),
1511            ..Default::default()
1512        };
1513
1514        let resolved = partial.resolve();
1515
1516        assert_eq!(resolved.editor.tab_size, 2);
1517        assert!(!resolved.editor.line_numbers);
1518    }
1519
1520    #[test]
1521    fn roundtrip_config_to_partial_and_back() {
1522        let original = crate::config::Config::default();
1523        let partial = PartialConfig::from(&original);
1524        let resolved = partial.resolve();
1525
1526        assert_eq!(original.theme, resolved.theme);
1527        assert_eq!(original.editor.tab_size, resolved.editor.tab_size);
1528        assert_eq!(original.check_for_updates, resolved.check_for_updates);
1529    }
1530
1531    #[test]
1532    fn session_config_new_is_empty() {
1533        let session = SessionConfig::new();
1534        assert!(session.is_empty());
1535    }
1536
1537    #[test]
1538    fn session_config_set_theme() {
1539        let mut session = SessionConfig::new();
1540        session.set_theme(ThemeName::from("dark"));
1541        assert_eq!(session.theme, Some(ThemeName::from("dark")));
1542        assert!(!session.is_empty());
1543    }
1544
1545    #[test]
1546    fn session_config_clear_theme() {
1547        let mut session = SessionConfig::new();
1548        session.set_theme(ThemeName::from("dark"));
1549        session.clear_theme();
1550        assert!(session.theme.is_none());
1551    }
1552
1553    #[test]
1554    fn session_config_set_editor_option() {
1555        let mut session = SessionConfig::new();
1556        session.set_editor_option(|e| e.tab_size = Some(2));
1557        assert_eq!(session.editor.as_ref().unwrap().tab_size, Some(2));
1558    }
1559
1560    #[test]
1561    fn session_config_buffer_overrides() {
1562        let mut session = SessionConfig::new();
1563        let path = std::path::PathBuf::from("/test/file.rs");
1564        let config = PartialEditorConfig {
1565            tab_size: Some(8),
1566            ..Default::default()
1567        };
1568
1569        session.set_buffer_override(path.clone(), config);
1570        assert!(session.get_buffer_override(&path).is_some());
1571        assert_eq!(
1572            session.get_buffer_override(&path).unwrap().tab_size,
1573            Some(8)
1574        );
1575
1576        session.clear_buffer_override(&path);
1577        assert!(session.get_buffer_override(&path).is_none());
1578    }
1579
1580    #[test]
1581    fn session_config_to_partial_config() {
1582        let mut session = SessionConfig::new();
1583        session.set_theme(ThemeName::from("dark"));
1584        session.set_editor_option(|e| e.tab_size = Some(2));
1585
1586        let partial = session.to_partial_config();
1587        assert_eq!(partial.theme, Some(ThemeName::from("dark")));
1588        assert_eq!(partial.editor.as_ref().unwrap().tab_size, Some(2));
1589    }
1590
1591    // ============= Plugin Config Delta Saving Tests =============
1592
1593    #[test]
1594    fn plugins_with_default_enabled_not_serialized() {
1595        // When all plugins have enabled=true (the default), plugins should be None
1596        let mut config = crate::config::Config::default();
1597        config.plugins.insert(
1598            "test_plugin".to_string(),
1599            PluginConfig {
1600                enabled: true, // Default value
1601                path: Some(std::path::PathBuf::from("/path/to/plugin.ts")),
1602                settings: serde_json::Value::Null,
1603            },
1604        );
1605
1606        let partial = PartialConfig::from(&config);
1607
1608        // plugins should be None since all have default values
1609        assert!(
1610            partial.plugins.is_none(),
1611            "Plugins with default enabled=true should not be serialized"
1612        );
1613    }
1614
1615    #[test]
1616    fn plugins_with_disabled_are_serialized() {
1617        // When a plugin is disabled, it should be included in the partial config
1618        let mut config = crate::config::Config::default();
1619        config.plugins.insert(
1620            "enabled_plugin".to_string(),
1621            PluginConfig {
1622                enabled: true,
1623                path: Some(std::path::PathBuf::from("/path/to/enabled.ts")),
1624                settings: serde_json::Value::Null,
1625            },
1626        );
1627        config.plugins.insert(
1628            "disabled_plugin".to_string(),
1629            PluginConfig {
1630                enabled: false, // Not default!
1631                path: Some(std::path::PathBuf::from("/path/to/disabled.ts")),
1632                settings: serde_json::Value::Null,
1633            },
1634        );
1635
1636        let partial = PartialConfig::from(&config);
1637
1638        // plugins should contain only the disabled plugin
1639        assert!(partial.plugins.is_some());
1640        let plugins = partial.plugins.unwrap();
1641        assert_eq!(
1642            plugins.len(),
1643            1,
1644            "Only disabled plugins should be serialized"
1645        );
1646        assert!(plugins.contains_key("disabled_plugin"));
1647        assert!(!plugins.contains_key("enabled_plugin"));
1648
1649        // Check the disabled plugin has correct values
1650        let disabled = plugins.get("disabled_plugin").unwrap();
1651        assert_eq!(disabled.enabled, Some(false));
1652        // Path should be None - it's auto-discovered and shouldn't be saved
1653        assert!(disabled.path.is_none(), "Path should not be serialized");
1654    }
1655
1656    #[test]
1657    fn plugin_path_never_serialized() {
1658        // Even for disabled plugins, path should never be serialized
1659        let mut config = crate::config::Config::default();
1660        config.plugins.insert(
1661            "my_plugin".to_string(),
1662            PluginConfig {
1663                enabled: false,
1664                path: Some(std::path::PathBuf::from("/some/path/plugin.ts")),
1665                settings: serde_json::Value::Null,
1666            },
1667        );
1668
1669        let partial = PartialConfig::from(&config);
1670        let plugins = partial.plugins.unwrap();
1671        let plugin = plugins.get("my_plugin").unwrap();
1672
1673        assert!(
1674            plugin.path.is_none(),
1675            "Path is runtime-discovered and should never be serialized"
1676        );
1677    }
1678
1679    #[test]
1680    fn resolving_partial_with_disabled_plugin_preserves_state() {
1681        // Loading a config with a disabled plugin should preserve disabled state
1682        let partial = PartialConfig {
1683            plugins: Some(HashMap::from([(
1684                "my_plugin".to_string(),
1685                PartialPluginConfig {
1686                    enabled: Some(false),
1687                    path: None,
1688                    settings: serde_json::Value::Null,
1689                },
1690            )])),
1691            ..Default::default()
1692        };
1693
1694        let resolved = partial.resolve();
1695
1696        // Plugin should exist and be disabled
1697        let plugin = resolved.plugins.get("my_plugin");
1698        assert!(
1699            plugin.is_some(),
1700            "Disabled plugin should be in resolved config"
1701        );
1702        assert!(
1703            !plugin.unwrap().enabled,
1704            "Plugin should remain disabled after resolve"
1705        );
1706    }
1707
1708    #[test]
1709    fn merge_plugins_preserves_higher_precedence_disabled_state() {
1710        // When merging, higher precedence disabled state should win
1711        let mut higher = PartialConfig {
1712            plugins: Some(HashMap::from([(
1713                "my_plugin".to_string(),
1714                PartialPluginConfig {
1715                    enabled: Some(false), // User disabled
1716                    path: None,
1717                    settings: serde_json::Value::Null,
1718                },
1719            )])),
1720            ..Default::default()
1721        };
1722
1723        let lower = PartialConfig {
1724            plugins: Some(HashMap::from([(
1725                "my_plugin".to_string(),
1726                PartialPluginConfig {
1727                    enabled: Some(true), // Lower layer has it enabled
1728                    path: None,
1729                    settings: serde_json::Value::Null,
1730                },
1731            )])),
1732            ..Default::default()
1733        };
1734
1735        higher.merge_from(&lower);
1736
1737        let plugins = higher.plugins.unwrap();
1738        let plugin = plugins.get("my_plugin").unwrap();
1739        assert_eq!(
1740            plugin.enabled,
1741            Some(false),
1742            "Higher precedence disabled state should win"
1743        );
1744    }
1745
1746    #[test]
1747    fn roundtrip_disabled_plugin_only_saves_delta() {
1748        // Roundtrip test: create config with mix of enabled/disabled plugins,
1749        // convert to partial, serialize to JSON, deserialize, and verify
1750        let mut config = crate::config::Config::default();
1751        config.plugins.insert(
1752            "plugin_a".to_string(),
1753            PluginConfig {
1754                enabled: true,
1755                path: Some(std::path::PathBuf::from("/a.ts")),
1756                settings: serde_json::Value::Null,
1757            },
1758        );
1759        config.plugins.insert(
1760            "plugin_b".to_string(),
1761            PluginConfig {
1762                enabled: false,
1763                path: Some(std::path::PathBuf::from("/b.ts")),
1764                settings: serde_json::Value::Null,
1765            },
1766        );
1767        config.plugins.insert(
1768            "plugin_c".to_string(),
1769            PluginConfig {
1770                enabled: true,
1771                path: Some(std::path::PathBuf::from("/c.ts")),
1772                settings: serde_json::Value::Null,
1773            },
1774        );
1775
1776        // Convert to partial (delta)
1777        let partial = PartialConfig::from(&config);
1778
1779        // Serialize to JSON
1780        let json = serde_json::to_string(&partial).unwrap();
1781
1782        // Verify only plugin_b is in the JSON
1783        assert!(
1784            json.contains("plugin_b"),
1785            "Disabled plugin should be in serialized JSON"
1786        );
1787        assert!(
1788            !json.contains("plugin_a"),
1789            "Enabled plugin_a should not be in serialized JSON"
1790        );
1791        assert!(
1792            !json.contains("plugin_c"),
1793            "Enabled plugin_c should not be in serialized JSON"
1794        );
1795
1796        // Deserialize back
1797        let deserialized: PartialConfig = serde_json::from_str(&json).unwrap();
1798
1799        // Verify plugins section only contains the disabled one
1800        let plugins = deserialized.plugins.unwrap();
1801        assert_eq!(plugins.len(), 1);
1802        assert!(plugins.contains_key("plugin_b"));
1803        assert_eq!(plugins.get("plugin_b").unwrap().enabled, Some(false));
1804    }
1805}