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 experiments: FeatureFlags,
24 pub projects_online_by_default: bool,
25 pub buffer_font_family: FamilyId,
26 pub default_buffer_font_size: f32,
27 pub buffer_font_size: f32,
28 pub hover_popover_enabled: bool,
29 pub show_completions_on_input: bool,
30 pub vim_mode: bool,
31 pub autosave: Autosave,
32 pub default_dock_anchor: DockAnchor,
33 pub editor_defaults: EditorSettings,
34 pub editor_overrides: EditorSettings,
35 pub journal_defaults: JournalSettings,
36 pub journal_overrides: JournalSettings,
37 pub terminal_defaults: TerminalSettings,
38 pub terminal_overrides: TerminalSettings,
39 pub language_defaults: HashMap<Arc<str>, EditorSettings>,
40 pub language_overrides: HashMap<Arc<str>, EditorSettings>,
41 pub lsp: HashMap<Arc<str>, LspSettings>,
42 pub theme: Arc<Theme>,
43 pub staff_mode: bool,
44}
45
46#[derive(Copy, Clone, Debug, Default, Deserialize, JsonSchema)]
47pub struct FeatureFlags {
48 pub experimental_themes: bool,
49}
50
51impl FeatureFlags {
52 pub fn keymap_files(&self) -> Vec<&'static str> {
53 vec![]
54 }
55}
56
57#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
58pub struct EditorSettings {
59 pub tab_size: Option<NonZeroU32>,
60 pub hard_tabs: Option<bool>,
61 pub soft_wrap: Option<SoftWrap>,
62 pub preferred_line_length: Option<u32>,
63 pub format_on_save: Option<FormatOnSave>,
64 pub formatter: Option<Formatter>,
65 pub enable_language_server: Option<bool>,
66}
67
68#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
69#[serde(rename_all = "snake_case")]
70pub enum SoftWrap {
71 None,
72 EditorWidth,
73 PreferredLineLength,
74}
75#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
76#[serde(rename_all = "snake_case")]
77pub enum FormatOnSave {
78 On,
79 Off,
80 LanguageServer,
81 External {
82 command: String,
83 arguments: Vec<String>,
84 },
85}
86
87#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
88#[serde(rename_all = "snake_case")]
89pub enum Formatter {
90 LanguageServer,
91 External {
92 command: String,
93 arguments: Vec<String>,
94 },
95}
96
97#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
98#[serde(rename_all = "snake_case")]
99pub enum Autosave {
100 Off,
101 AfterDelay { milliseconds: u64 },
102 OnFocusChange,
103 OnWindowChange,
104}
105
106#[derive(Clone, Debug, Deserialize, JsonSchema)]
107pub struct JournalSettings {
108 pub path: Option<String>,
109 pub hour_format: Option<HourFormat>,
110}
111
112impl Default for JournalSettings {
113 fn default() -> Self {
114 Self {
115 path: Some("~".into()),
116 hour_format: Some(Default::default()),
117 }
118 }
119}
120
121#[derive(Clone, Debug, Deserialize, JsonSchema)]
122#[serde(rename_all = "snake_case")]
123pub enum HourFormat {
124 Hour12,
125 Hour24,
126}
127
128impl Default for HourFormat {
129 fn default() -> Self {
130 Self::Hour12
131 }
132}
133
134#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
135pub struct TerminalSettings {
136 pub shell: Option<Shell>,
137 pub working_directory: Option<WorkingDirectory>,
138 pub font_size: Option<f32>,
139 pub font_family: Option<String>,
140 pub env: Option<HashMap<String, String>>,
141 pub blinking: Option<TerminalBlink>,
142 pub alternate_scroll: Option<AlternateScroll>,
143 pub option_as_meta: Option<bool>,
144}
145
146#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
147#[serde(rename_all = "snake_case")]
148pub enum TerminalBlink {
149 Off,
150 TerminalControlled,
151 On,
152}
153
154impl Default for TerminalBlink {
155 fn default() -> Self {
156 TerminalBlink::TerminalControlled
157 }
158}
159
160#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
161#[serde(rename_all = "snake_case")]
162pub enum Shell {
163 System,
164 Program(String),
165 WithArguments { program: String, args: Vec<String> },
166}
167
168impl Default for Shell {
169 fn default() -> Self {
170 Shell::System
171 }
172}
173
174#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
175#[serde(rename_all = "snake_case")]
176pub enum AlternateScroll {
177 On,
178 Off,
179}
180
181impl Default for AlternateScroll {
182 fn default() -> Self {
183 AlternateScroll::On
184 }
185}
186
187#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
188#[serde(rename_all = "snake_case")]
189pub enum WorkingDirectory {
190 CurrentProjectDirectory,
191 FirstProjectDirectory,
192 AlwaysHome,
193 Always { directory: String },
194}
195
196#[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Deserialize, JsonSchema)]
197#[serde(rename_all = "snake_case")]
198pub enum DockAnchor {
199 #[default]
200 Bottom,
201 Right,
202 Expanded,
203}
204
205#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
206pub struct SettingsFileContent {
207 pub experiments: Option<FeatureFlags>,
208 #[serde(default)]
209 pub projects_online_by_default: Option<bool>,
210 #[serde(default)]
211 pub buffer_font_family: Option<String>,
212 #[serde(default)]
213 pub buffer_font_size: Option<f32>,
214 #[serde(default)]
215 pub hover_popover_enabled: Option<bool>,
216 #[serde(default)]
217 pub show_completions_on_input: Option<bool>,
218 #[serde(default)]
219 pub vim_mode: Option<bool>,
220 #[serde(default)]
221 pub autosave: Option<Autosave>,
222 #[serde(default)]
223 pub default_dock_anchor: Option<DockAnchor>,
224 #[serde(flatten)]
225 pub editor: EditorSettings,
226 #[serde(default)]
227 pub journal: JournalSettings,
228 #[serde(default)]
229 pub terminal: TerminalSettings,
230 #[serde(default)]
231 #[serde(alias = "language_overrides")]
232 pub languages: HashMap<Arc<str>, EditorSettings>,
233 #[serde(default)]
234 pub lsp: HashMap<Arc<str>, LspSettings>,
235 #[serde(default)]
236 pub theme: Option<String>,
237 #[serde(default)]
238 pub staff_mode: Option<bool>,
239}
240
241#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
242#[serde(rename_all = "snake_case")]
243pub struct LspSettings {
244 pub initialization_options: Option<Value>,
245}
246
247impl Settings {
248 pub fn defaults(
249 assets: impl AssetSource,
250 font_cache: &FontCache,
251 themes: &ThemeRegistry,
252 ) -> Self {
253 #[track_caller]
254 fn required<T>(value: Option<T>) -> Option<T> {
255 assert!(value.is_some(), "missing default setting value");
256 value
257 }
258
259 let defaults: SettingsFileContent = parse_json_with_comments(
260 str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
261 )
262 .unwrap();
263
264 Self {
265 experiments: FeatureFlags::default(),
266 buffer_font_family: font_cache
267 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
268 .unwrap(),
269 buffer_font_size: defaults.buffer_font_size.unwrap(),
270 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
271 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
272 show_completions_on_input: defaults.show_completions_on_input.unwrap(),
273 projects_online_by_default: defaults.projects_online_by_default.unwrap(),
274 vim_mode: defaults.vim_mode.unwrap(),
275 autosave: defaults.autosave.unwrap(),
276 default_dock_anchor: defaults.default_dock_anchor.unwrap(),
277 editor_defaults: EditorSettings {
278 tab_size: required(defaults.editor.tab_size),
279 hard_tabs: required(defaults.editor.hard_tabs),
280 soft_wrap: required(defaults.editor.soft_wrap),
281 preferred_line_length: required(defaults.editor.preferred_line_length),
282 format_on_save: required(defaults.editor.format_on_save),
283 formatter: required(defaults.editor.formatter),
284 enable_language_server: required(defaults.editor.enable_language_server),
285 },
286 editor_overrides: Default::default(),
287 journal_defaults: Default::default(),
288 journal_overrides: Default::default(),
289 terminal_defaults: Default::default(),
290 terminal_overrides: Default::default(),
291 language_defaults: defaults.languages,
292 language_overrides: Default::default(),
293 lsp: defaults.lsp.clone(),
294 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
295
296 staff_mode: false,
297 }
298 }
299
300 pub fn set_user_settings(
301 &mut self,
302 data: SettingsFileContent,
303 theme_registry: &ThemeRegistry,
304 font_cache: &FontCache,
305 ) {
306 if let Some(value) = &data.buffer_font_family {
307 if let Some(id) = font_cache.load_family(&[value]).log_err() {
308 self.buffer_font_family = id;
309 }
310 }
311 if let Some(value) = &data.theme {
312 if let Some(theme) = theme_registry.get(value).log_err() {
313 self.theme = theme;
314 }
315 }
316
317 merge(
318 &mut self.projects_online_by_default,
319 data.projects_online_by_default,
320 );
321 merge(&mut self.buffer_font_size, data.buffer_font_size);
322 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
323 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
324 merge(
325 &mut self.show_completions_on_input,
326 data.show_completions_on_input,
327 );
328 merge(&mut self.vim_mode, data.vim_mode);
329 merge(&mut self.autosave, data.autosave);
330 merge(&mut self.experiments, data.experiments);
331 merge(&mut self.staff_mode, data.staff_mode);
332 merge(&mut self.default_dock_anchor, data.default_dock_anchor);
333
334 // Ensure terminal font is loaded, so we can request it in terminal_element layout
335 if let Some(terminal_font) = &data.terminal.font_family {
336 font_cache.load_family(&[terminal_font]).log_err();
337 }
338
339 self.editor_overrides = data.editor;
340 self.journal_overrides = data.journal;
341 self.terminal_defaults.font_size = data.terminal.font_size;
342 self.terminal_overrides = data.terminal;
343 self.language_overrides = data.languages;
344 self.lsp = data.lsp;
345 }
346
347 pub fn with_language_defaults(
348 mut self,
349 language_name: impl Into<Arc<str>>,
350 overrides: EditorSettings,
351 ) -> Self {
352 self.language_defaults
353 .insert(language_name.into(), overrides);
354 self
355 }
356
357 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
358 self.language_setting(language, |settings| settings.tab_size)
359 }
360
361 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
362 self.language_setting(language, |settings| settings.hard_tabs)
363 }
364
365 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
366 self.language_setting(language, |settings| settings.soft_wrap)
367 }
368
369 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
370 self.language_setting(language, |settings| settings.preferred_line_length)
371 }
372
373 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
374 self.language_setting(language, |settings| settings.format_on_save.clone())
375 }
376
377 pub fn formatter(&self, language: Option<&str>) -> Formatter {
378 self.language_setting(language, |settings| settings.formatter.clone())
379 }
380
381 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
382 self.language_setting(language, |settings| settings.enable_language_server)
383 }
384
385 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
386 where
387 F: Fn(&EditorSettings) -> Option<R>,
388 {
389 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
390 .or_else(|| f(&self.editor_overrides))
391 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
392 .or_else(|| f(&self.editor_defaults))
393 .expect("missing default")
394 }
395
396 #[cfg(any(test, feature = "test-support"))]
397 pub fn test(cx: &gpui::AppContext) -> Settings {
398 Settings {
399 experiments: FeatureFlags::default(),
400 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
401 buffer_font_size: 14.,
402 default_buffer_font_size: 14.,
403 hover_popover_enabled: true,
404 show_completions_on_input: true,
405 vim_mode: false,
406 autosave: Autosave::Off,
407 default_dock_anchor: DockAnchor::Bottom,
408 editor_defaults: EditorSettings {
409 tab_size: Some(4.try_into().unwrap()),
410 hard_tabs: Some(false),
411 soft_wrap: Some(SoftWrap::None),
412 preferred_line_length: Some(80),
413 format_on_save: Some(FormatOnSave::On),
414 formatter: Some(Formatter::LanguageServer),
415 enable_language_server: Some(true),
416 },
417 editor_overrides: Default::default(),
418 journal_defaults: Default::default(),
419 journal_overrides: Default::default(),
420 terminal_defaults: Default::default(),
421 terminal_overrides: Default::default(),
422 language_defaults: Default::default(),
423 language_overrides: Default::default(),
424 lsp: Default::default(),
425 projects_online_by_default: true,
426 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), Default::default),
427 staff_mode: false,
428 }
429 }
430
431 #[cfg(any(test, feature = "test-support"))]
432 pub fn test_async(cx: &mut gpui::TestAppContext) {
433 cx.update(|cx| {
434 let settings = Self::test(cx);
435 cx.set_global(settings);
436 });
437 }
438}
439
440pub fn settings_file_json_schema(
441 theme_names: Vec<String>,
442 language_names: &[String],
443) -> serde_json::Value {
444 let settings = SchemaSettings::draft07().with(|settings| {
445 settings.option_add_null_type = false;
446 });
447 let generator = SchemaGenerator::new(settings);
448 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
449
450 // Create a schema for a theme name.
451 let theme_name_schema = SchemaObject {
452 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
453 enum_values: Some(theme_names.into_iter().map(Value::String).collect()),
454 ..Default::default()
455 };
456
457 // Create a schema for a 'languages overrides' object, associating editor
458 // settings with specific langauges.
459 assert!(root_schema.definitions.contains_key("EditorSettings"));
460 let languages_object_schema = SchemaObject {
461 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
462 object: Some(Box::new(ObjectValidation {
463 properties: language_names
464 .iter()
465 .map(|name| {
466 (
467 name.clone(),
468 Schema::new_ref("#/definitions/EditorSettings".into()),
469 )
470 })
471 .collect(),
472 ..Default::default()
473 })),
474 ..Default::default()
475 };
476
477 // Add these new schemas as definitions, and modify properties of the root
478 // schema to reference them.
479 root_schema.definitions.extend([
480 ("ThemeName".into(), theme_name_schema.into()),
481 ("Languages".into(), languages_object_schema.into()),
482 ]);
483 let root_schema_object = &mut root_schema.schema.object.as_mut().unwrap();
484
485 // Avoid automcomplete for non-user facing settings
486 root_schema_object.properties.remove("staff_mode");
487 root_schema_object.properties.extend([
488 (
489 "theme".to_owned(),
490 Schema::new_ref("#/definitions/ThemeName".into()),
491 ),
492 (
493 "languages".to_owned(),
494 Schema::new_ref("#/definitions/Languages".into()),
495 ),
496 // For backward compatibility
497 (
498 "language_overrides".to_owned(),
499 Schema::new_ref("#/definitions/Languages".into()),
500 ),
501 ]);
502
503 serde_json::to_value(root_schema).unwrap()
504}
505
506fn merge<T: Copy>(target: &mut T, value: Option<T>) {
507 if let Some(value) = value {
508 *target = value;
509 }
510}
511
512pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
513 Ok(serde_json::from_reader(
514 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
515 )?)
516}