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