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