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