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