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