1mod keymap_file;
2
3use anyhow::Result;
4use gpui::{
5 font_cache::{FamilyId, FontCache},
6 AssetSource,
7};
8use schemars::{
9 gen::{SchemaGenerator, SchemaSettings},
10 schema::{
11 InstanceType, ObjectValidation, Schema, SchemaObject, SingleOrVec, SubschemaValidation,
12 },
13 JsonSchema,
14};
15use serde::{de::DeserializeOwned, Deserialize};
16use serde_json::Value;
17use std::{collections::HashMap, num::NonZeroU32, sync::Arc};
18use theme::{Theme, ThemeRegistry};
19use util::ResultExt as _;
20
21pub use keymap_file::{keymap_file_json_schema, KeymapFileContent};
22
23#[derive(Clone)]
24pub struct Settings {
25 pub projects_online_by_default: bool,
26 pub buffer_font_family: FamilyId,
27 pub buffer_font_size: f32,
28 pub default_buffer_font_size: f32,
29 pub hover_popover_enabled: bool,
30 pub vim_mode: bool,
31 pub autosave: Autosave,
32 pub editor_defaults: LanguageSettings,
33 pub editor_overrides: LanguageSettings,
34 pub language_defaults: HashMap<Arc<str>, LanguageSettings>,
35 pub language_overrides: HashMap<Arc<str>, LanguageSettings>,
36 pub theme: Arc<Theme>,
37}
38
39#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
40pub struct LanguageSettings {
41 pub tab_size: Option<NonZeroU32>,
42 pub hard_tabs: Option<bool>,
43 pub soft_wrap: Option<SoftWrap>,
44 pub preferred_line_length: Option<u32>,
45 pub format_on_save: Option<FormatOnSave>,
46 pub enable_language_server: Option<bool>,
47}
48
49#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
50#[serde(rename_all = "snake_case")]
51pub enum SoftWrap {
52 None,
53 EditorWidth,
54 PreferredLineLength,
55}
56
57#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
58#[serde(rename_all = "snake_case")]
59pub enum FormatOnSave {
60 Off,
61 LanguageServer,
62 External {
63 command: String,
64 arguments: Vec<String>,
65 },
66}
67
68#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
69#[serde(rename_all = "snake_case")]
70pub enum Autosave {
71 Off,
72 AfterDelay { milliseconds: u64 },
73 OnFocusChange,
74 OnWindowChange,
75}
76
77#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
78pub struct SettingsFileContent {
79 #[serde(default)]
80 pub projects_online_by_default: Option<bool>,
81 #[serde(default)]
82 pub buffer_font_family: Option<String>,
83 #[serde(default)]
84 pub buffer_font_size: Option<f32>,
85 #[serde(default)]
86 pub hover_popover_enabled: Option<bool>,
87 #[serde(default)]
88 pub vim_mode: Option<bool>,
89 #[serde(default)]
90 pub autosave: Option<Autosave>,
91 #[serde(flatten)]
92 pub editor: LanguageSettings,
93 #[serde(default)]
94 pub language_overrides: HashMap<Arc<str>, LanguageSettings>,
95 #[serde(default)]
96 pub theme: Option<String>,
97}
98
99impl Settings {
100 pub fn defaults(
101 assets: impl AssetSource,
102 font_cache: &FontCache,
103 themes: &ThemeRegistry,
104 ) -> Self {
105 fn required<T>(value: Option<T>) -> Option<T> {
106 assert!(value.is_some(), "missing default setting value");
107 value
108 }
109
110 let defaults: SettingsFileContent =
111 serde_json::from_slice(assets.load("default-settings.json").unwrap().as_ref()).unwrap();
112
113 Self {
114 buffer_font_family: font_cache
115 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
116 .unwrap(),
117 buffer_font_size: defaults.buffer_font_size.unwrap(),
118 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
119 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
120 projects_online_by_default: defaults.projects_online_by_default.unwrap(),
121 vim_mode: defaults.vim_mode.unwrap(),
122 autosave: defaults.autosave.unwrap(),
123 editor_defaults: LanguageSettings {
124 tab_size: required(defaults.editor.tab_size),
125 hard_tabs: required(defaults.editor.hard_tabs),
126 soft_wrap: required(defaults.editor.soft_wrap),
127 preferred_line_length: required(defaults.editor.preferred_line_length),
128 format_on_save: required(defaults.editor.format_on_save),
129 enable_language_server: required(defaults.editor.enable_language_server),
130 },
131 language_defaults: defaults.language_overrides,
132 editor_overrides: Default::default(),
133 language_overrides: Default::default(),
134 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
135 }
136 }
137
138 pub fn with_language_defaults(
139 mut self,
140 language_name: impl Into<Arc<str>>,
141 overrides: LanguageSettings,
142 ) -> Self {
143 self.language_defaults
144 .insert(language_name.into(), overrides);
145 self
146 }
147
148 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
149 self.language_setting(language, |settings| settings.tab_size)
150 }
151
152 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
153 self.language_setting(language, |settings| settings.hard_tabs)
154 }
155
156 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
157 self.language_setting(language, |settings| settings.soft_wrap)
158 }
159
160 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
161 self.language_setting(language, |settings| settings.preferred_line_length)
162 }
163
164 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
165 self.language_setting(language, |settings| settings.format_on_save.clone())
166 }
167
168 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
169 self.language_setting(language, |settings| settings.enable_language_server)
170 }
171
172 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
173 where
174 F: Fn(&LanguageSettings) -> Option<R>,
175 {
176 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
177 .or_else(|| f(&self.editor_overrides))
178 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
179 .or_else(|| f(&self.editor_defaults))
180 .expect("missing default")
181 }
182
183 #[cfg(any(test, feature = "test-support"))]
184 pub fn test(cx: &gpui::AppContext) -> Settings {
185 Settings {
186 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
187 buffer_font_size: 14.,
188 default_buffer_font_size: 14.,
189 hover_popover_enabled: true,
190 vim_mode: false,
191 autosave: Autosave::Off,
192 editor_defaults: LanguageSettings {
193 tab_size: Some(4.try_into().unwrap()),
194 hard_tabs: Some(false),
195 soft_wrap: Some(SoftWrap::None),
196 preferred_line_length: Some(80),
197 format_on_save: Some(FormatOnSave::LanguageServer),
198 enable_language_server: Some(true),
199 },
200 editor_overrides: Default::default(),
201 language_defaults: Default::default(),
202 language_overrides: Default::default(),
203 projects_online_by_default: true,
204 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), || Default::default()),
205 }
206 }
207
208 #[cfg(any(test, feature = "test-support"))]
209 pub fn test_async(cx: &mut gpui::TestAppContext) {
210 cx.update(|cx| {
211 let settings = Self::test(cx);
212 cx.set_global(settings.clone());
213 });
214 }
215
216 pub fn merge(
217 &mut self,
218 data: &SettingsFileContent,
219 theme_registry: &ThemeRegistry,
220 font_cache: &FontCache,
221 ) {
222 if let Some(value) = &data.buffer_font_family {
223 if let Some(id) = font_cache.load_family(&[value]).log_err() {
224 self.buffer_font_family = id;
225 }
226 }
227 if let Some(value) = &data.theme {
228 if let Some(theme) = theme_registry.get(&value.to_string()).log_err() {
229 self.theme = theme;
230 }
231 }
232
233 merge(
234 &mut self.projects_online_by_default,
235 data.projects_online_by_default,
236 );
237 merge(&mut self.buffer_font_size, data.buffer_font_size);
238 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
239 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
240 merge(&mut self.vim_mode, data.vim_mode);
241 merge(&mut self.autosave, data.autosave);
242
243 merge_option(
244 &mut self.editor_overrides.format_on_save,
245 data.editor.format_on_save.clone(),
246 );
247 merge_option(
248 &mut self.editor_overrides.enable_language_server,
249 data.editor.enable_language_server,
250 );
251 merge_option(&mut self.editor_overrides.soft_wrap, data.editor.soft_wrap);
252 merge_option(&mut self.editor_overrides.tab_size, data.editor.tab_size);
253 merge_option(
254 &mut self.editor_overrides.preferred_line_length,
255 data.editor.preferred_line_length,
256 );
257
258 for (language_name, settings) in data.language_overrides.clone().into_iter() {
259 let target = self
260 .language_overrides
261 .entry(language_name.into())
262 .or_default();
263
264 merge_option(&mut target.tab_size, settings.tab_size);
265 merge_option(&mut target.soft_wrap, settings.soft_wrap);
266 merge_option(&mut target.format_on_save, settings.format_on_save);
267 merge_option(
268 &mut target.enable_language_server,
269 settings.enable_language_server,
270 );
271 merge_option(
272 &mut target.preferred_line_length,
273 settings.preferred_line_length,
274 );
275 }
276 }
277}
278
279pub fn settings_file_json_schema(
280 theme_names: Vec<String>,
281 language_names: Vec<String>,
282) -> serde_json::Value {
283 let settings = SchemaSettings::draft07().with(|settings| {
284 settings.option_add_null_type = false;
285 });
286 let generator = SchemaGenerator::new(settings);
287 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
288
289 // Construct theme names reference type
290 let theme_names = theme_names
291 .into_iter()
292 .map(|name| Value::String(name))
293 .collect();
294 let theme_names_schema = Schema::Object(SchemaObject {
295 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
296 enum_values: Some(theme_names),
297 ..Default::default()
298 });
299 root_schema
300 .definitions
301 .insert("ThemeName".to_owned(), theme_names_schema);
302
303 // Construct language settings reference type
304 let language_settings_schema_reference = Schema::Object(SchemaObject {
305 reference: Some("#/definitions/LanguageSettings".to_owned()),
306 ..Default::default()
307 });
308 let language_settings_properties = language_names
309 .into_iter()
310 .map(|name| {
311 (
312 name,
313 Schema::Object(SchemaObject {
314 subschemas: Some(Box::new(SubschemaValidation {
315 all_of: Some(vec![language_settings_schema_reference.clone()]),
316 ..Default::default()
317 })),
318 ..Default::default()
319 }),
320 )
321 })
322 .collect();
323 let language_overrides_schema = Schema::Object(SchemaObject {
324 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
325 object: Some(Box::new(ObjectValidation {
326 properties: language_settings_properties,
327 ..Default::default()
328 })),
329 ..Default::default()
330 });
331 root_schema
332 .definitions
333 .insert("LanguageOverrides".to_owned(), language_overrides_schema);
334
335 // Modify theme property to use new theme reference type
336 let settings_file_schema = root_schema.schema.object.as_mut().unwrap();
337 let language_overrides_schema_reference = Schema::Object(SchemaObject {
338 reference: Some("#/definitions/ThemeName".to_owned()),
339 ..Default::default()
340 });
341 settings_file_schema.properties.insert(
342 "theme".to_owned(),
343 Schema::Object(SchemaObject {
344 subschemas: Some(Box::new(SubschemaValidation {
345 all_of: Some(vec![language_overrides_schema_reference]),
346 ..Default::default()
347 })),
348 ..Default::default()
349 }),
350 );
351
352 // Modify language_overrides property to use LanguageOverrides reference
353 settings_file_schema.properties.insert(
354 "language_overrides".to_owned(),
355 Schema::Object(SchemaObject {
356 reference: Some("#/definitions/LanguageOverrides".to_owned()),
357 ..Default::default()
358 }),
359 );
360 serde_json::to_value(root_schema).unwrap()
361}
362
363fn merge<T: Copy>(target: &mut T, value: Option<T>) {
364 if let Some(value) = value {
365 *target = value;
366 }
367}
368
369fn merge_option<T>(target: &mut Option<T>, value: Option<T>) {
370 if value.is_some() {
371 *target = value;
372 }
373}
374
375pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
376 Ok(serde_json::from_reader(
377 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
378 )?)
379}