1use crate::{watched_json::WatchedJsonFile, write_top_level_setting, SettingsFileContent};
2use anyhow::Result;
3use fs::Fs;
4use gpui::MutableAppContext;
5use serde_json::Value;
6use std::{path::Path, sync::Arc};
7
8// TODO: Switch SettingsFile to open a worktree and buffer for synchronization
9// And instant updates in the Zed editor
10#[derive(Clone)]
11pub struct SettingsFile {
12 path: &'static Path,
13 settings_file_content: WatchedJsonFile<SettingsFileContent>,
14 fs: Arc<dyn Fs>,
15}
16
17impl SettingsFile {
18 pub fn new(
19 path: &'static Path,
20 settings_file_content: WatchedJsonFile<SettingsFileContent>,
21 fs: Arc<dyn Fs>,
22 ) -> Self {
23 SettingsFile {
24 path,
25 settings_file_content,
26 fs,
27 }
28 }
29
30 pub fn update(cx: &mut MutableAppContext, update: impl FnOnce(&mut SettingsFileContent)) {
31 let this = cx.global::<SettingsFile>();
32
33 let current_file_content = this.settings_file_content.current();
34 let mut new_file_content = current_file_content.clone();
35
36 update(&mut new_file_content);
37
38 let fs = this.fs.clone();
39 let path = this.path.clone();
40
41 cx.background()
42 .spawn(async move {
43 // Unwrap safety: These values are all guarnteed to be well formed, and we know
44 // that they will deserialize to our settings object. All of the following unwraps
45 // are therefore safe.
46 let tmp = serde_json::to_value(current_file_content).unwrap();
47 let old_json = tmp.as_object().unwrap();
48
49 let new_tmp = serde_json::to_value(new_file_content).unwrap();
50 let new_json = new_tmp.as_object().unwrap();
51
52 // Find changed fields
53 let mut diffs = vec![];
54 for (key, old_value) in old_json.iter() {
55 let new_value = new_json.get(key).unwrap();
56 if old_value != new_value {
57 if matches!(
58 new_value,
59 &Value::Null | &Value::Object(_) | &Value::Array(_)
60 ) {
61 unimplemented!(
62 "We only support updating basic values at the top level"
63 );
64 }
65
66 let new_json = serde_json::to_string_pretty(new_value)
67 .expect("Could not serialize new json field to string");
68
69 diffs.push((key, new_json));
70 }
71 }
72
73 // Have diffs, rewrite the settings file now.
74 let mut content = fs.load(path).await?;
75
76 for (key, new_value) in diffs {
77 content = write_top_level_setting(content, key, &new_value)
78 }
79
80 fs.atomic_write(path.to_path_buf(), content).await?;
81
82 Ok(()) as Result<()>
83 })
84 .detach_and_log_err(cx);
85 }
86}
87
88#[cfg(test)]
89mod tests {
90 use super::*;
91 use crate::{watched_json::watch_settings_file, EditorSettings, Settings, SoftWrap};
92 use fs::FakeFs;
93 use theme::ThemeRegistry;
94
95 #[gpui::test]
96 async fn test_watch_settings_files(cx: &mut gpui::TestAppContext) {
97 let executor = cx.background();
98 let fs = FakeFs::new(executor.clone());
99 let font_cache = cx.font_cache();
100
101 fs.save(
102 "/settings.json".as_ref(),
103 &r#"
104 {
105 "buffer_font_size": 24,
106 "soft_wrap": "editor_width",
107 "tab_size": 8,
108 "language_overrides": {
109 "Markdown": {
110 "tab_size": 2,
111 "preferred_line_length": 100,
112 "soft_wrap": "preferred_line_length"
113 }
114 }
115 }
116 "#
117 .into(),
118 Default::default(),
119 )
120 .await
121 .unwrap();
122
123 let source = WatchedJsonFile::new(fs.clone(), &executor, "/settings.json".as_ref()).await;
124
125 let default_settings = cx.read(Settings::test).with_language_defaults(
126 "JavaScript",
127 EditorSettings {
128 tab_size: Some(2.try_into().unwrap()),
129 ..Default::default()
130 },
131 );
132 cx.update(|cx| {
133 watch_settings_file(
134 default_settings.clone(),
135 source,
136 ThemeRegistry::new((), font_cache),
137 cx,
138 )
139 });
140
141 cx.foreground().run_until_parked();
142 let settings = cx.read(|cx| cx.global::<Settings>().clone());
143 assert_eq!(settings.buffer_font_size, 24.0);
144
145 assert_eq!(settings.soft_wrap(None), SoftWrap::EditorWidth);
146 assert_eq!(
147 settings.soft_wrap(Some("Markdown")),
148 SoftWrap::PreferredLineLength
149 );
150 assert_eq!(
151 settings.soft_wrap(Some("JavaScript")),
152 SoftWrap::EditorWidth
153 );
154
155 assert_eq!(settings.preferred_line_length(None), 80);
156 assert_eq!(settings.preferred_line_length(Some("Markdown")), 100);
157 assert_eq!(settings.preferred_line_length(Some("JavaScript")), 80);
158
159 assert_eq!(settings.tab_size(None).get(), 8);
160 assert_eq!(settings.tab_size(Some("Markdown")).get(), 2);
161 assert_eq!(settings.tab_size(Some("JavaScript")).get(), 8);
162
163 fs.save(
164 "/settings.json".as_ref(),
165 &"(garbage)".into(),
166 Default::default(),
167 )
168 .await
169 .unwrap();
170 // fs.remove_file("/settings.json".as_ref(), Default::default())
171 // .await
172 // .unwrap();
173
174 cx.foreground().run_until_parked();
175 let settings = cx.read(|cx| cx.global::<Settings>().clone());
176 assert_eq!(settings.buffer_font_size, 24.0);
177
178 assert_eq!(settings.soft_wrap(None), SoftWrap::EditorWidth);
179 assert_eq!(
180 settings.soft_wrap(Some("Markdown")),
181 SoftWrap::PreferredLineLength
182 );
183 assert_eq!(
184 settings.soft_wrap(Some("JavaScript")),
185 SoftWrap::EditorWidth
186 );
187
188 assert_eq!(settings.preferred_line_length(None), 80);
189 assert_eq!(settings.preferred_line_length(Some("Markdown")), 100);
190 assert_eq!(settings.preferred_line_length(Some("JavaScript")), 80);
191
192 assert_eq!(settings.tab_size(None).get(), 8);
193 assert_eq!(settings.tab_size(Some("Markdown")).get(), 2);
194 assert_eq!(settings.tab_size(Some("JavaScript")).get(), 8);
195
196 fs.remove_file("/settings.json".as_ref(), Default::default())
197 .await
198 .unwrap();
199 cx.foreground().run_until_parked();
200 let settings = cx.read(|cx| cx.global::<Settings>().clone());
201 assert_eq!(settings.buffer_font_size, default_settings.buffer_font_size);
202 }
203}