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 set_user_settings(
140 &mut self,
141 data: SettingsFileContent,
142 theme_registry: &ThemeRegistry,
143 font_cache: &FontCache,
144 ) {
145 if let Some(value) = &data.buffer_font_family {
146 if let Some(id) = font_cache.load_family(&[value]).log_err() {
147 self.buffer_font_family = id;
148 }
149 }
150 if let Some(value) = &data.theme {
151 if let Some(theme) = theme_registry.get(&value.to_string()).log_err() {
152 self.theme = theme;
153 }
154 }
155
156 merge(
157 &mut self.projects_online_by_default,
158 data.projects_online_by_default,
159 );
160 merge(&mut self.buffer_font_size, data.buffer_font_size);
161 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
162 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
163 merge(&mut self.vim_mode, data.vim_mode);
164 merge(&mut self.autosave, data.autosave);
165
166 self.editor_overrides = data.editor;
167 self.language_overrides = data.languages;
168 }
169
170 pub fn with_language_defaults(
171 mut self,
172 language_name: impl Into<Arc<str>>,
173 overrides: EditorSettings,
174 ) -> Self {
175 self.language_defaults
176 .insert(language_name.into(), overrides);
177 self
178 }
179
180 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
181 self.language_setting(language, |settings| settings.tab_size)
182 }
183
184 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
185 self.language_setting(language, |settings| settings.hard_tabs)
186 }
187
188 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
189 self.language_setting(language, |settings| settings.soft_wrap)
190 }
191
192 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
193 self.language_setting(language, |settings| settings.preferred_line_length)
194 }
195
196 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
197 self.language_setting(language, |settings| settings.format_on_save.clone())
198 }
199
200 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
201 self.language_setting(language, |settings| settings.enable_language_server)
202 }
203
204 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
205 where
206 F: Fn(&EditorSettings) -> Option<R>,
207 {
208 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
209 .or_else(|| f(&self.editor_overrides))
210 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
211 .or_else(|| f(&self.editor_defaults))
212 .expect("missing default")
213 }
214
215 #[cfg(any(test, feature = "test-support"))]
216 pub fn test(cx: &gpui::AppContext) -> Settings {
217 Settings {
218 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
219 buffer_font_size: 14.,
220 default_buffer_font_size: 14.,
221 hover_popover_enabled: true,
222 vim_mode: false,
223 autosave: Autosave::Off,
224 editor_defaults: EditorSettings {
225 tab_size: Some(4.try_into().unwrap()),
226 hard_tabs: Some(false),
227 soft_wrap: Some(SoftWrap::None),
228 preferred_line_length: Some(80),
229 format_on_save: Some(FormatOnSave::LanguageServer),
230 enable_language_server: Some(true),
231 },
232 editor_overrides: Default::default(),
233 language_defaults: Default::default(),
234 language_overrides: Default::default(),
235 projects_online_by_default: true,
236 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), || Default::default()),
237 }
238 }
239
240 #[cfg(any(test, feature = "test-support"))]
241 pub fn test_async(cx: &mut gpui::TestAppContext) {
242 cx.update(|cx| {
243 let settings = Self::test(cx);
244 cx.set_global(settings.clone());
245 });
246 }
247}
248
249pub fn settings_file_json_schema(
250 theme_names: Vec<String>,
251 language_names: &[String],
252) -> serde_json::Value {
253 let settings = SchemaSettings::draft07().with(|settings| {
254 settings.option_add_null_type = false;
255 });
256 let generator = SchemaGenerator::new(settings);
257 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
258
259 // Create a schema for a theme name.
260 let theme_name_schema = SchemaObject {
261 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
262 enum_values: Some(
263 theme_names
264 .into_iter()
265 .map(|name| Value::String(name))
266 .collect(),
267 ),
268 ..Default::default()
269 };
270
271 // Create a schema for a 'languages overrides' object, associating editor
272 // settings with specific langauges.
273 assert!(root_schema.definitions.contains_key("EditorSettings"));
274 let languages_object_schema = SchemaObject {
275 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
276 object: Some(Box::new(ObjectValidation {
277 properties: language_names
278 .iter()
279 .map(|name| {
280 (
281 name.clone(),
282 Schema::new_ref("#/definitions/EditorSettings".into()),
283 )
284 })
285 .collect(),
286 ..Default::default()
287 })),
288 ..Default::default()
289 };
290
291 // Add these new schemas as definitions, and modify properties of the root
292 // schema to reference them.
293 root_schema.definitions.extend([
294 ("ThemeName".into(), theme_name_schema.into()),
295 ("Languages".into(), languages_object_schema.into()),
296 ]);
297 root_schema
298 .schema
299 .object
300 .as_mut()
301 .unwrap()
302 .properties
303 .extend([
304 (
305 "theme".to_owned(),
306 Schema::new_ref("#/definitions/ThemeName".into()),
307 ),
308 (
309 "languages".to_owned(),
310 Schema::new_ref("#/definitions/Languages".into()),
311 ),
312 // For backward compatibility
313 (
314 "language_overrides".to_owned(),
315 Schema::new_ref("#/definitions/Languages".into()),
316 ),
317 ]);
318
319 serde_json::to_value(root_schema).unwrap()
320}
321
322fn merge<T: Copy>(target: &mut T, value: Option<T>) {
323 if let Some(value) = value {
324 *target = value;
325 }
326}
327
328pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
329 Ok(serde_json::from_reader(
330 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
331 )?)
332}